lsst::afw::table::FieldBase< std::string > Struct Reference

Field base class specialization for strings. More...

#include <FieldBase.h>

Inheritance diagram for lsst::afw::table::FieldBase< std::string >:

Public Types
using	Value = std::string
	the type returned by BaseRecord::get
using	Reference = char *
	the type returned by BaseRecord::operator[]
using	ConstReference = const char *
	the type returned by BaseRecord::operator[] (const)
using	Element = char
	the type of subfields and array elements

Public Member Functions
	FieldBase (std::size_t size=std::numeric_limits< size_t >::max())
	Construct a FieldBase with the given size.
	FieldBase (FieldBase const &) noexcept=default
	FieldBase (FieldBase &&) noexcept=default
FieldBase &	operator= (FieldBase const &) noexcept=default
FieldBase &	operator= (FieldBase &&) noexcept=default
	~FieldBase () noexcept=default
std::size_t	getElementCount () const noexcept
	Return the number of subfield elements (equal to the size of the string, including a null terminator), or 0 for a variable-length string.
std::size_t	getSize () const noexcept
	Return the maximum length of the string, including a null terminator (equal to the number of subfield elements), or 0 for a variable-length string.
bool	isVariableLength () const noexcept
	Return true if the field is variable-length (each record can have a different size array).

Static Public Member Functions
static std::string	getTypeString ()
	Return a string description of the field type.

Protected Member Functions
void	stream (std::ostream &os) const
	Defines how Fields are printed.
Reference	getReference (Element *p, ndarray::Manager::Ptr const &m) const
	Used to implement BaseRecord::operator[] (non-const).
ConstReference	getConstReference (Element const *p, ndarray::Manager::Ptr const &m) const
	Used to implement BaseRecord::operator[] (const).
Value	getValue (Element const *p, ndarray::Manager::Ptr const &m) const
	Used to implement BaseRecord::get.
void	setValue (Element *p, ndarray::Manager::Ptr const &, std::string const &value) const
	Used to implement BaseRecord::set Fixed-lengths strings are handled by copying the data into p through p + _size, nulling extra characters, if any.

Static Protected Member Functions
static FieldBase	makeDefault () noexcept
	Needed to allow Keys to be default-constructed.

Detailed Description

Field base class specialization for strings.

Definition at line 218 of file FieldBase.h.

Member Typedef Documentation

ConstReference

using lsst::afw::table::FieldBase< std::string >::ConstReference = const char *

the type returned by BaseRecord::operator[] (const)

Definition at line 225 of file FieldBase.h.

Element

using lsst::afw::table::FieldBase< std::string >::Element = char

the type of subfields and array elements

Definition at line 227 of file FieldBase.h.

Reference

using lsst::afw::table::FieldBase< std::string >::Reference = char *

the type returned by BaseRecord::operator[]

Definition at line 222 of file FieldBase.h.

Value

using lsst::afw::table::FieldBase< std::string >::Value = std::string

the type returned by BaseRecord::get

Definition at line 219 of file FieldBase.h.

Constructor & Destructor Documentation

FieldBase() [1/3]

lsst::afw::table::FieldBase< std::string >::FieldBase

(

std::size_t

size = std::numeric_limits<size_t>::max()

)

Construct a FieldBase with the given size.

A size == 0 indicates a variable-length string. Negative sizes are not permitted.

This constructor is implicit and has an invalid default so it can be used in the Field constructor (as if it were an int argument) without specializing Field. In other words, it allows one to construct a 25-character string field like this:

Field< std::string >("name", "documentation", 25);

...even though the third argument to the Field constructor takes a FieldBase, not an int.

Definition at line 69 of file FieldBase.cc.

                                              : _size(size) {
}

FieldBase() [2/3]

lsst::afw::table::FieldBase< std::string >::FieldBase ( FieldBase< std::string > const & )

defaultnoexcept

FieldBase() [3/3]

lsst::afw::table::FieldBase< std::string >::FieldBase ( FieldBase< std::string > && )

defaultnoexcept

~FieldBase()

lsst::afw::table::FieldBase< std::string >::~FieldBase ( )

defaultnoexcept

Member Function Documentation

getConstReference()

ConstReference lsst::afw::table::FieldBase< std::string >::getConstReference ( Element const * p, ndarray::Manager::Ptr const & m ) const

inlineprotected

Used to implement BaseRecord::operator[] (const).

Definition at line 283 of file FieldBase.h.

                                                                                         {
        if (isVariableLength()) {
            return reinterpret_cast<std::string const *>(p)->data();
        } else {
            return p;
        }
    }

getElementCount()

std::size_t lsst::afw::table::FieldBase< std::string >::getElementCount ( ) const

inlinenoexcept

Return the number of subfield elements (equal to the size of the string, including a null terminator), or 0 for a variable-length string.

Definition at line 255 of file FieldBase.h.

{ return _size; }

getReference()

Reference lsst::afw::table::FieldBase< std::string >::getReference ( Element * p, ndarray::Manager::Ptr const & m ) const

inlineprotected

Used to implement BaseRecord::operator[] (non-const).

Definition at line 272 of file FieldBase.h.

                                                                         {
        if (isVariableLength()) {
            // Can't be done until C++17, which allows read/write access to std::string's internal buffer
            throw LSST_EXCEPT(lsst::pex::exceptions::LogicError,
                              "non-const operator[] not supported for variable-length strings");
        } else {
            return p;
        }
    }

getSize()

std::size_t lsst::afw::table::FieldBase< std::string >::getSize ( ) const

inlinenoexcept

Return the maximum length of the string, including a null terminator (equal to the number of subfield elements), or 0 for a variable-length string.

Definition at line 259 of file FieldBase.h.

{ return _size; }

getTypeString()

std::string lsst::afw::table::FieldBase< std::string >::getTypeString ( )

static

Return a string description of the field type.

Definition at line 72 of file FieldBase.cc.

{ return "String"; }

getValue()

std::string lsst::afw::table::FieldBase< std::string >::getValue ( Element const * p, ndarray::Manager::Ptr const & m ) const

protected

Used to implement BaseRecord::get.

Definition at line 74 of file FieldBase.cc.

                                                                                           {
    if (isVariableLength()) {
        // p is a pointer to a std::string; return a copy
        return std::string(*reinterpret_cast<std::string const *>(p));
    } else {
        // p is a char * that is null-terminated only if the string has fewer than _size chars;
        // return a copy as a std::string
        Element const *end = p + _size;
        end = std::find(p, end, 0);
        return std::string(p, end);
    }
}

isVariableLength()

bool lsst::afw::table::FieldBase< std::string >::isVariableLength ( ) const

inlinenoexcept

Return true if the field is variable-length (each record can have a different size array).

Definition at line 262 of file FieldBase.h.

{ return _size == 0; }

makeDefault()

static FieldBase lsst::afw::table::FieldBase< std::string >::makeDefault ( )

inlinestaticprotectednoexcept

Needed to allow Keys to be default-constructed.

Definition at line 266 of file FieldBase.h.

{ return FieldBase(0); }

operator=() [1/2]

FieldBase & lsst::afw::table::FieldBase< std::string >::operator= ( FieldBase< std::string > && )

defaultnoexcept

operator=() [2/2]

FieldBase & lsst::afw::table::FieldBase< std::string >::operator= ( FieldBase< std::string > const & )

defaultnoexcept

setValue()

void lsst::afw::table::FieldBase< std::string >::setValue ( Element * p, ndarray::Manager::Ptr const & , std::string const & value ) const

protected

Used to implement BaseRecord::set Fixed-lengths strings are handled by copying the data into p through p + _size, nulling extra characters, if any.

The data is only null-terminated if value.size() < _size. Variable-length strings are handled by setting p to the address of a std::string that is a copy of value

Definition at line 87 of file FieldBase.cc.

                                                                    {
    if (isVariableLength()) {
        // p is a pointer to a std::string; replace its contents with a copy of `value`
        *reinterpret_cast<std::string *>(p) = value;
    } else {
        // copy the contents of `value` to p through p + _size, null extra characters, if any
        if (value.size() > _size) {
            throw LSST_EXCEPT(
                    lsst::pex::exceptions::LengthError,
                    (boost::format("String (%d) is too large for field (%d).") % value.size() % _size).str());
        }
        std::copy(value.begin(), value.end(), p);
        std::fill(p + value.size(), p + _size, char(0));  // null extra characters, if any
    }
}

stream()

void lsst::afw::table::FieldBase< std::string >::stream ( std::ostream & os ) const

inlineprotected

Defines how Fields are printed.

Definition at line 269 of file FieldBase.h.

{ os << ", size=" << _size; }

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/afw/gf92a8ffd38+e7bc33f3ea/include/lsst/afw/table/FieldBase.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/afw/gf92a8ffd38+e7bc33f3ea/src/table/FieldBase.cc