lsst::afw::table::ArrayKey< T > Class Template Reference

A FunctorKey used to get or set a ndarray::Array from a sequence of scalar Keys. More...

#include <arrays.h>

Inheritance diagram for lsst::afw::table::ArrayKey< T >:

Public Types
using	Value
	The data type for get and set.

Public Member Functions
	ArrayKey () noexcept
	Default constructor; instance will not be usable unless subsequently assigned to.
	ArrayKey (std::vector< Key< T > > const &keys)
	Construct from a vector of scalar Keys.
	ArrayKey (Key< Array< T > > const &other) noexcept
	Construct from a compound Key< Array<T> >
	ArrayKey (SubSchema const &s)
	Construct from a subschema, assuming *_0, *_1, *_2, etc.
	ArrayKey (ArrayKey const &) noexcept
	ArrayKey (ArrayKey &&) noexcept
ArrayKey &	operator= (ArrayKey const &) noexcept
ArrayKey &	operator= (ArrayKey &&) noexcept
	~ArrayKey () noexcept override
std::size_t	getSize () const noexcept
	Return the number of elements in the array.
ndarray::Array< T const, 1, 1 >	get (BaseRecord const &record) const override
	Get an array from the given record.
void	set (BaseRecord &record, ndarray::Array< T const, 1, 1 > const &value) const override
	Set an array in the given record.
ndarray::ArrayRef< T, 1, 1 >	getReference (BaseRecord &record) const override
	Get non-const reference array from the given record.
ndarray::ArrayRef< T const, 1, 1 >	getConstReference (BaseRecord const &record) const override
	Get const reference array from the given record.
bool	operator== (ArrayKey< T > const &other) const noexcept
	Compare the FunctorKey for equality with another, using the underlying scalar Keys.
bool	operator!= (ArrayKey< T > const &other) const noexcept
std::size_t	hash_value () const noexcept
	Return a hash of this object.
bool	isValid () const noexcept
	Return True if the FunctorKey contains valid scalar keys.
Key< T >	operator[] (std::size_t i) const
	Return a scalar Key for an element of the array.
ArrayKey	slice (std::size_t begin, std::size_t end) const
	Return a FunctorKey corresponding to a range of elements.
virtual void	set (BaseRecord &record, T const &value) const =0

Static Public Member Functions
static ArrayKey	addFields (Schema &schema, std::string const &name, std::string const &doc, std::string const &unit, std::vector< T > const &docData)
	Add an array of fields to a Schema, and return an ArrayKey that points to them.
static ArrayKey	addFields (Schema &schema, std::string const &name, std::string const &doc, std::string const &unit, size_t size)
	Add an array of fields to a Schema, and return an ArrayKey that points to them.

Detailed Description

template<typename T>
class lsst::afw::table::ArrayKey< T >

A FunctorKey used to get or set a ndarray::Array from a sequence of scalar Keys.

ArrayKey operates on the convention that arrays are defined by a set of contiguous scalar fields (i.e. added to the Schema in order, with no interruption) of the same type, with a common field name prefix and "_0", "_1" etc. suffixes.

Definition at line 43 of file arrays.h.

Member Typedef Documentation

Value

using lsst::afw::table::FunctorKey< T >::Value

inherited

The data type for get and set.

Definition at line 77 of file FunctorKey.h.

Constructor & Destructor Documentation

ArrayKey() [1/6]

template<typename T >

lsst::afw::table::ArrayKey< T >::ArrayKey ( )

inlinenoexcept

Default constructor; instance will not be usable unless subsequently assigned to.

Definition at line 78 of file arrays.h.

: _begin(), _size(0) {}

ArrayKey() [2/6]

template<typename T >

lsst::afw::table::ArrayKey< T >::ArrayKey ( std::vector< Key< T > > const & keys )

explicit

Construct from a vector of scalar Keys.

Definition at line 66 of file arrays.cc.

                                                    : _begin(), _size(keys.size()) {
    if (keys.empty()) return;
    _begin = keys.front();
    for (std::size_t i = 1; i < _size; ++i) {
        if (keys[i].getOffset() - _begin.getOffset() != (i * sizeof(T))) {
            throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                              "Keys passed to ArrayKey constructor are not contiguous");
        }
    }
}

ArrayKey() [3/6]

template<typename T >

lsst::afw::table::ArrayKey< T >::ArrayKey ( Key< Array< T > > const & other )

explicitnoexcept

Construct from a compound Key< Array<T> >

Key< Array<T> > is needed in some cases, but ArrayKey should be preferred in new code when possible. This converting constructor is intended to aid compatibility between the two.

Definition at line 78 of file arrays.cc.

: _begin(other[0]), _size(other.getSize()) {}

ArrayKey() [4/6]

template<typename T >

lsst::afw::table::ArrayKey< T >::ArrayKey ( SubSchema const & s )

explicit

Construct from a subschema, assuming *_0, *_1, *_2, etc.

subfields

If a schema has "a_0", "a_1", and "a_2" fields, this constructor allows you to construct a 3-element ArrayKey via:

ArrayKey<T> k(schema["a"]);

Definition at line 81 of file arrays.cc.

                                        : _begin(s["0"]), _size(1) {
    Key<T> current;
    while (true) {
        try {
            current = s[std::to_string(_size)];
        } catch (pex::exceptions::NotFoundError &) {
            return;
        }
        if (current.getOffset() - _begin.getOffset() != (_size * sizeof(T))) {
            throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                              "Keys discovered in Schema are not contiguous");
        }
        ++_size;
    }
}

ArrayKey() [5/6]

template<typename T >

lsst::afw::table::ArrayKey< T >::ArrayKey ( ArrayKey< T > const & )

defaultnoexcept

ArrayKey() [6/6]

template<typename T >

lsst::afw::table::ArrayKey< T >::ArrayKey ( ArrayKey< T > && )

defaultnoexcept

~ArrayKey()

template<typename T >

lsst::afw::table::ArrayKey< T >::~ArrayKey ( )

overridedefaultnoexcept

Member Function Documentation

addFields() [1/2]

template<typename T >

ArrayKey< T > lsst::afw::table::ArrayKey< T >::addFields ( Schema & schema, std::string const & name, std::string const & doc, std::string const & unit, size_t size )

static

Add an array of fields to a Schema, and return an ArrayKey that points to them.

Parameters

[in,out]	schema	Schema to add fields to.
[in]	name	Name prefix for all fields; "_0", "_1", etc. will be appended to this to form the full field names.
[in]	doc	String used as the documentation for the fields.
[in]	unit	String used as the unit for all fields.
[in]	size	Number of fields to add.

Definition at line 51 of file arrays.cc.

                                                                       {
    ArrayKey result;
    if (size == 0) return result;
    result._size = size;
    result._begin = schema.addField<T>(
            schema.join(name, "0"),  // we use getPrefix in order to get the version-dependent delimiter
            doc, unit);
    for (std::size_t i = 1; i < result._size; ++i) {
        schema.addField<T>(schema.join(name, std::to_string(i)), doc, unit);
    }
    return result;
}

addFields() [2/2]

template<typename T >

ArrayKey< T > lsst::afw::table::ArrayKey< T >::addFields ( Schema & schema, std::string const & name, std::string const & doc, std::string const & unit, std::vector< T > const & docData )

static

Add an array of fields to a Schema, and return an ArrayKey that points to them.

Parameters

[in,out]	schema	Schema to add fields to.
[in]	name	Name prefix for all fields; "_0", "_1", etc. will be appended to this to form the full field names.
[in]	doc	String used as the documentation for the fields. Should include a single boost::format template string, which will be substituted with the appropriate element from the docData array to form the full documentation string.
[in]	unit	String used as the unit for all fields.
[in]	docData	Vector of values substituted into the doc fields. The length of the vector determines the number of fields added.

Definition at line 35 of file arrays.cc.

                                                                                       {
    ArrayKey<T> result;
    if (docData.empty()) return result;
    result._size = docData.size();
    result._begin = schema.addField<T>(
            schema.join(name, "0"),  // we use getPrefix in order to get the version-dependent delimiter
            (boost::format(doc) % docData.front()).str(), unit);
    for (std::size_t i = 1; i < result._size; ++i) {
        schema.addField<T>(schema.join(name, std::to_string(i)), (boost::format(doc) % docData[i]).str(),
                           unit);
    }
    return result;
}

get()

template<typename T >

ndarray::Array< T const, 1, 1 > lsst::afw::table::ArrayKey< T >::get ( BaseRecord const & record ) const

overridevirtual

Get an array from the given record.

Implements lsst::afw::table::OutputFunctorKey< T >.

Definition at line 109 of file arrays.cc.

                                                                           {
    return ndarray::external(record.getElement(_begin), ndarray::makeVector(_size), ndarray::ROW_MAJOR,
                             record.getManager());
}

getConstReference()

template<typename T >

ndarray::ArrayRef< T const, 1, 1 > lsst::afw::table::ArrayKey< T >::getConstReference ( BaseRecord const & record ) const

overridevirtual

Get const reference array from the given record.

Implements lsst::afw::table::ConstReferenceFunctorKey< ndarray::ArrayRef< T const, 1, 1 > >.

Definition at line 129 of file arrays.cc.

                                                                                            {
    return ndarray::external(record.getElement(_begin), ndarray::makeVector(_size), ndarray::ROW_MAJOR,
                             record.getManager());
}

getReference()

template<typename T >

ndarray::ArrayRef< T, 1, 1 > lsst::afw::table::ArrayKey< T >::getReference ( BaseRecord & record ) const

overridevirtual

Get non-const reference array from the given record.

Implements lsst::afw::table::ReferenceFunctorKey< ndarray::ArrayRef< T, 1, 1 > >.

Definition at line 123 of file arrays.cc.

                                                                           {
    return ndarray::external(record.getElement(_begin), ndarray::makeVector(_size), ndarray::ROW_MAJOR,
                             record.getManager());
}

getSize()

template<typename T >

std::size_t lsst::afw::table::ArrayKey< T >::getSize ( ) const

inlinenoexcept

Return the number of elements in the array.

Definition at line 108 of file arrays.h.

{ return _size; }

hash_value()

template<typename T >

std::size_t lsst::afw::table::ArrayKey< T >::hash_value ( ) const

inlinenoexcept

Return a hash of this object.

Definition at line 131 of file arrays.h.

                                          {
        // Completely arbitrary seed
        return utils::hashCombine(17, _begin, _size);
    }

isValid()

template<typename T >

bool lsst::afw::table::ArrayKey< T >::isValid ( ) const

inlinenoexcept

Return True if the FunctorKey contains valid scalar keys.

Definition at line 137 of file arrays.h.

{ return _begin.isValid(); }

operator!=()

template<typename T >

bool lsst::afw::table::ArrayKey< T >::operator!= ( ArrayKey< T > const & other ) const

inlinenoexcept

Definition at line 127 of file arrays.h.

{ return !operator==(other); }

operator=() [1/2]

template<typename T >

ArrayKey< T > & lsst::afw::table::ArrayKey< T >::operator= ( ArrayKey< T > && )

defaultnoexcept

operator=() [2/2]

template<typename T >

ArrayKey< T > & lsst::afw::table::ArrayKey< T >::operator= ( ArrayKey< T > const & )

defaultnoexcept

operator==()

template<typename T >

bool lsst::afw::table::ArrayKey< T >::operator== ( ArrayKey< T > const & other ) const

inlinenoexcept

Compare the FunctorKey for equality with another, using the underlying scalar Keys.

Definition at line 124 of file arrays.h.

                                                             {
        return other._begin == _begin && other._size == _size;
    }

operator[]()

template<typename T >

Key< T > lsst::afw::table::ArrayKey< T >::operator[]

(

std::size_t

i

)

const

Return a scalar Key for an element of the array.

Definition at line 135 of file arrays.cc.

                                                {
    if (i >= _size) {
        throw LSST_EXCEPT(pex::exceptions::LengthError, "ArrayKey index does not fit within valid range");
    }
    return detail::Access::makeKey<T>(_begin.getOffset() + i * sizeof(T));
}

set() [1/2]

template<typename T >

void lsst::afw::table::ArrayKey< T >::set ( BaseRecord & record, ndarray::Array< T const, 1, 1 > const & value ) const

override

Set an array in the given record.

Definition at line 115 of file arrays.cc.

                                                                                        {
    LSST_THROW_IF_NE(value.template getSize<0>(), static_cast<std::size_t>(_size),
                     pex::exceptions::LengthError,
                     "Size of input array (%d) does not match size of array field (%d)");
    std::copy(value.begin(), value.end(), record.getElement(_begin));
}

set() [2/2]

template<typename T >

virtual void lsst::afw::table::InputFunctorKey< T >::set ( BaseRecord & record, T const & value ) const

pure virtualinherited

slice()

template<typename T >

ArrayKey< T > lsst::afw::table::ArrayKey< T >::slice	(	std::size_t	begin,
		std::size_t	end ) const

Return a FunctorKey corresponding to a range of elements.

Definition at line 143 of file arrays.cc.

                                                                   {
    if (begin >= end || end > _size) {
        throw LSST_EXCEPT(pex::exceptions::LengthError,
                          "ArrayKey slice range does not fit within valid range");
    }
    return ArrayKey((*this)[begin], end - begin);
}

---

The documentation for this class was generated from the following files:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+53520f316c/include/lsst/afw/table/arrays.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+53520f316c/src/table/arrays.cc