lsst::afw::table::detail::SchemaImpl Class Reference

A private implementation class to hide the messy details of Schema. More...

#include <SchemaImpl.h>

Public Types
using	ItemVariant = decltype(makeItemVariantType(FieldTypes{}))
	A Boost.Variant type that can hold any one of the allowed SchemaItem types.
using	ItemContainer = std::vector<ItemVariant>
	A std::vector whose elements can be any of the allowed SchemaItem types.
using	NameMap = std::map<std::string, std::size_t>
	A map from field names to position in the vector, so we can do name lookups.
using	OffsetMap = std::map<std::size_t, std::size_t>
	A map from standard field offsets to position in the vector, so we can do field lookups.
using	FlagMap = std::map<std::pair<std::size_t, std::size_t>, std::size_t>
	A map from Flag field offset/bit pairs to position in the vector, so we can do Flag field lookups.

Public Member Functions
std::size_t	getRecordSize () const
	The size of a record in bytes.
std::size_t	getFieldCount () const
	The total number of fields.
std::size_t	getFlagFieldCount () const
	The number of Flag fields.
std::size_t	getNonFlagFieldCount () const
	The number of non-Flag fields.
template<typename T >
SchemaItem< T >	find (std::string const &name) const
	Find an item by name (used to implement Schema::find).
template<typename T >
SchemaItem< T >	find (Key< T > const &key) const
	Find an item by key (used to implement Schema::find).
SchemaItem< Flag >	find (Key< Flag > const &key) const
	Find an item by key (used to implement Schema::find).
template<typename F >
decltype(auto)	findAndApply (std::string const &name, F &&func) const
	Find an item by name and run the given functor on it.
std::set< std::string >	getNames (bool topOnly) const
	Return a set of field names (used to implement Schema::getNames).
std::set< std::string >	getNames (bool topOnly, std::string const &prefix) const
	Return a set of field names (used to implement SubSchema::getNames).
template<typename T >
int	contains (SchemaItem< T > const &item, int flags) const
template<typename T >
Key< T >	addField (Field< T > const &field, bool doReplace=false)
	Add a field to the schema (used to implement Schema::addField).
Key< Flag >	addField (Field< Flag > const &field, bool doReplace=false)
	Add a field to the schema (used to implement Schema::addField).
template<typename T >
Key< Array< T > >	addField (Field< Array< T > > const &field, bool doReplace=false)
	Add a field to the schema (used to implement Schema::addField).
Key< std::string >	addField (Field< std::string > const &field, bool doReplace=false)
	Add a field to the schema (used to implement Schema::addField).
template<typename T >
void	replaceField (Key< T > const &key, Field< T > const &field)
	Replace the Field in an existing SchemaItem without changing the Key.
ItemContainer const &	getItems () const
	Return the vector of SchemaItem variants.
	SchemaImpl ()
	Default constructor.

Static Public Attributes
static int const	VERSION = 3

Friends
class	detail::Access

Detailed Description

A private implementation class to hide the messy details of Schema.

This can't be a real pimpl class, because some of the most important functionality is in the forEach function, a templated function we can't explicitly instantiate in a source file. But putting all the details here draws a clear line between what users should look at (Schema) and what they shouldn't (this).

Because Schema holds SchemaImpl by shared pointer, one SchemaImpl can be shared between multiple Schemas (and SubSchemas), which implement copy-on-write by creating a new SchemaImpl if the pointer they have isn't unique when they are modified.

Definition at line 45 of file SchemaImpl.h.

Member Typedef Documentation

FlagMap

using lsst::afw::table::detail::SchemaImpl::FlagMap = std::map<std::pair<std::size_t, std::size_t>, std::size_t>

A map from Flag field offset/bit pairs to position in the vector, so we can do Flag field lookups.

Definition at line 63 of file SchemaImpl.h.

ItemContainer

using lsst::afw::table::detail::SchemaImpl::ItemContainer = std::vector<ItemVariant>

A std::vector whose elements can be any of the allowed SchemaItem types.

Definition at line 57 of file SchemaImpl.h.

ItemVariant

using lsst::afw::table::detail::SchemaImpl::ItemVariant = decltype(makeItemVariantType(FieldTypes{}))

A Boost.Variant type that can hold any one of the allowed SchemaItem types.

Definition at line 55 of file SchemaImpl.h.

NameMap

using lsst::afw::table::detail::SchemaImpl::NameMap = std::map<std::string, std::size_t>

A map from field names to position in the vector, so we can do name lookups.

Definition at line 59 of file SchemaImpl.h.

OffsetMap

using lsst::afw::table::detail::SchemaImpl::OffsetMap = std::map<std::size_t, std::size_t>

A map from standard field offsets to position in the vector, so we can do field lookups.

Definition at line 61 of file SchemaImpl.h.

Constructor & Destructor Documentation

SchemaImpl()

lsst::afw::table::detail::SchemaImpl::SchemaImpl ( )

inline

Default constructor.

Definition at line 136 of file SchemaImpl.h.

: _recordSize(0), _lastFlagField(0), _lastFlagBit(0), _items(), _initFlag(false) {}

Member Function Documentation

addField() [1/4]

template<typename T >

Key< Array< T > > lsst::afw::table::detail::SchemaImpl::addField	(	Field< Array< T > > const &	field,
		bool	doReplace = false )

Add a field to the schema (used to implement Schema::addField).

Definition at line 294 of file Schema.cc.

                                                                                 {
    if (field.isVariableLength()) {
        // Variable-length array: allocate space for one ndarray
        return addFieldImpl(sizeof(ndarray::Array<T, 1, 1>), 1, field, doReplace);
    }
    // Fixed-length array: allocate space for getElementCount() elements of type T
    return addFieldImpl(sizeof(typename Field<T>::Element), field.getElementCount(), field, doReplace);
}

addField() [2/4]

Key< Flag > lsst::afw::table::detail::SchemaImpl::addField	(	Field< Flag > const &	field,
		bool	doReplace = false )

Add a field to the schema (used to implement Schema::addField).

Definition at line 318 of file Schema.cc.

                                                                       {
    static std::size_t const ELEMENT_SIZE = sizeof(Field<Flag>::Element);
    std::pair<NameMap::iterator, bool> result =
            _names.insert(std::pair<std::string, std::size_t>(field.getName(), _items.size()));
    if (!result.second) {
        if (doReplace) {
            SchemaItem<Flag> *item = std::get_if<SchemaItem<Flag>>(&_items[result.first->second]);
            if (!item) {
                throw LSST_EXCEPT(
                        lsst::pex::exceptions::TypeError,
                        (boost::format("Cannot replace field with name '%s' because types differ.") %
                         field.getName())
                                .str());
            }
            if (item->field.getElementCount() != field.getElementCount()) {
                throw LSST_EXCEPT(
                        lsst::pex::exceptions::TypeError,
                        (boost::format("Cannot replace field with name '%s' because sizes differ.") %
                         field.getName())
                                .str());
            }
            item->field = field;
            return item->key;
        } else {
            throw LSST_EXCEPT(
                    lsst::pex::exceptions::InvalidParameterError,
                    (boost::format("Field with name '%s' already present in schema.") % field.getName())
                            .str());
        }
    } else {
        if (!_initFlag || _lastFlagBit >= ELEMENT_SIZE * 8) {
            std::size_t padding = ELEMENT_SIZE - _recordSize % ELEMENT_SIZE;
            if (padding != ELEMENT_SIZE) {
                _recordSize += padding;
            }
            _lastFlagField = _recordSize;
            _lastFlagBit = 0;
            _initFlag = true;
            _recordSize += field.getElementCount() * ELEMENT_SIZE;
        }
        SchemaItem<Flag> item(detail::Access::makeKey(_lastFlagField, _lastFlagBit), field);
        ++_lastFlagBit;
        _flags.insert(std::pair<std::pair<size_t, size_t>, size_t>(
                std::make_pair(item.key.getOffset(), item.key.getBit()), _items.size()));
        _items.push_back(item);
        return item.key;
    }
}

addField() [3/4]

Key< std::string > lsst::afw::table::detail::SchemaImpl::addField	(	Field< std::string > const &	field,
		bool	doReplace = false )

Add a field to the schema (used to implement Schema::addField).

Definition at line 303 of file Schema.cc.

                                                                                 {
    if (field.isVariableLength()) {
        // Variable-length string: allocate space for one std::string
        return addFieldImpl(sizeof(std::string), 1, field, doReplace);
    }
    // Fixed-length string: allocate space for getElementCount() chars
    return addFieldImpl(sizeof(typename Field<std::string>::Element), field.getElementCount(), field,
                        doReplace);
}

addField() [4/4]

template<typename T >

Key< T > lsst::afw::table::detail::SchemaImpl::addField	(	Field< T > const &	field,
		bool	doReplace = false )

Add a field to the schema (used to implement Schema::addField).

Definition at line 314 of file Schema.cc.

                                                                 {
    return addFieldImpl(sizeof(typename Field<T>::Element), field.getElementCount(), field, doReplace);
}

contains()

template<typename T >

int lsst::afw::table::detail::SchemaImpl::contains	(	SchemaItem< T > const &	item,
		int	flags ) const

Definition at line 225 of file Schema.cc.

                                                                   {
    if (!(flags & Schema::EQUAL_KEYS)) {
        throw LSST_EXCEPT(pex::exceptions::LogicError,
                          "Can only check whether item is in schema if flags & EQUAL_KEYS");
    }
    SchemaItem<T> const *cmpItem = nullptr;
    std::size_t index = findKey(_offsets, _flags, item.key, false);
    if (index != std::numeric_limits<size_t>::max()) {
        cmpItem = std::get_if<SchemaItem<T> >(&_items[index]);
        if (!cmpItem) {
            if ((flags & Schema::EQUAL_NAMES) && cmpItem->field.getName() != item.field.getName()) {
                flags &= ~Schema::EQUAL_NAMES;
            }
            if ((flags & Schema::EQUAL_DOCS) && cmpItem->field.getDoc() != item.field.getDoc()) {
                flags &= ~Schema::EQUAL_DOCS;
            }
            if ((flags & Schema::EQUAL_UNITS) && cmpItem->field.getUnits() != item.field.getUnits()) {
                flags &= ~Schema::EQUAL_UNITS;
            }
        }
    } else {
        flags = 0;
    }
    return flags;
}

find() [1/3]

SchemaItem< Flag > lsst::afw::table::detail::SchemaImpl::find

(

Key< Flag > const &

key

)

const

Find an item by key (used to implement Schema::find).

Definition at line 126 of file Schema.cc.

                                                            {
    FlagMap::const_iterator i = _flags.lower_bound(std::make_pair(key.getOffset(), key.getBit()));
    if (i != _flags.end()) {
        if (i->first.first == key.getOffset() && i->first.second == key.getBit()) {
            try {
                return std::get<SchemaItem<Flag>>(_items[i->second]);
            } catch (std::bad_variant_access &err) {
                throw LSST_EXCEPT(lsst::pex::exceptions::NotFoundError,
                                  (boost::format("Flag field with offset %d and bit %d not found.") %
                                   key.getOffset() % key.getBit())
                                          .str());
            }
        }
    }
    throw LSST_EXCEPT(lsst::pex::exceptions::NotFoundError,
                      (boost::format("Flag field with offset %d and bit %d not found.") % key.getOffset() %
                       key.getBit())
                              .str());
}

find() [2/3]

template<typename T >

SchemaItem< T > lsst::afw::table::detail::SchemaImpl::find

(

Key< T > const &

key

)

const

Find an item by key (used to implement Schema::find).

Definition at line 110 of file Schema.cc.

                                                      {
    OffsetMap::const_iterator i = _offsets.lower_bound(key.getOffset());
    if (i != _offsets.end() && i->first == key.getOffset()) {
        try {
            return std::get<SchemaItem<T>>(_items[i->second]);
        } catch (std::bad_variant_access &err) {
            // just swallow the exception; this might be a subfield key that points to the beginning.
        }
    }
    throw LSST_EXCEPT(lsst::pex::exceptions::NotFoundError,
                      (boost::format("Field or subfield with offset %d not found with type '%s'.") %
                       key.getOffset() % Field<T>::getTypeString())
                              .str());
}

find() [3/3]

template<typename T >

SchemaItem< T > lsst::afw::table::detail::SchemaImpl::find

(

std::string const &

name

)

const

Find an item by name (used to implement Schema::find).

Definition at line 92 of file Schema.cc.

                                                          {
    NameMap::const_iterator i = _names.lower_bound(name);
    if (i != _names.end() && i->first == name) {
        // got an exact match; we're done if it has the right type, and dead if it doesn't.
        try {
            return std::get<SchemaItem<T>>(_items[i->second]);
        } catch (std::bad_variant_access &err) {
            throw LSST_EXCEPT(lsst::pex::exceptions::TypeError,
                                (boost::format("Field '%s' does not have the given type.") % name).str());
        }
    }
    throw LSST_EXCEPT(lsst::pex::exceptions::NotFoundError,
                      (boost::format("Field with name '%s' not found with type '%s'.") % name %
                       Field<T>::getTypeString())
                              .str());
}

findAndApply()

template<typename F >

decltype(auto) lsst::afw::table::detail::SchemaImpl::findAndApply ( std::string const & name, F && func ) const

inline

Find an item by name and run the given functor on it.

Definition at line 90 of file SchemaImpl.h.

                                                                       {
        auto iter = _names.find(name);
        if (iter == _names.end()) {
            throw LSST_EXCEPT(pex::exceptions::NotFoundError,
                              (boost::format("Field with name '%s' not found") % name).str());
        }
        return std::visit(std::forward<F>(func), _items[iter->second]);
    }

getFieldCount()

std::size_t lsst::afw::table::detail::SchemaImpl::getFieldCount ( ) const

inline

The total number of fields.

Definition at line 69 of file SchemaImpl.h.

{ return _names.size(); }

getFlagFieldCount()

std::size_t lsst::afw::table::detail::SchemaImpl::getFlagFieldCount ( ) const

inline

The number of Flag fields.

Definition at line 72 of file SchemaImpl.h.

{ return _flags.size(); }

getItems()

ItemContainer const & lsst::afw::table::detail::SchemaImpl::getItems ( ) const

inline

Return the vector of SchemaItem variants.

Fields are in the order they are added. That means they're also ordered with increasing Key offsets, except for Flag fields, which are in increasing order of (offset, bit) relative to each other, but not relative to all the other fields.

Definition at line 133 of file SchemaImpl.h.

{ return _items; }

getNames() [1/2]

std::set< std::string > lsst::afw::table::detail::SchemaImpl::getNames

(

bool

topOnly

)

const

Return a set of field names (used to implement Schema::getNames).

Definition at line 251 of file Schema.cc.

                                                         {
    std::set<std::string> result;
    if (topOnly) {
        for (auto const &_name : _names) {
            std::size_t sep = _name.first.find(getDelimiter());
            if (sep == std::string::npos) {
                result.insert(result.end(), _name.first);
            } else {
                result.insert(result.end(), _name.first.substr(0, sep));
            }
        }
    } else {
        for (auto const &_name : _names) {
            result.insert(result.end(), _name.first);
        }
    }
    return result;
}

getNames() [2/2]

std::set< std::string > lsst::afw::table::detail::SchemaImpl::getNames	(	bool	topOnly,
		std::string const &	prefix ) const

Return a set of field names (used to implement SubSchema::getNames).

Definition at line 270 of file Schema.cc.

                                                                                  {
    std::set<std::string> result;
    if (topOnly) {
        for (NameMap::const_iterator i = _names.lower_bound(prefix); i != _names.end(); ++i) {
            if (i->first.compare(0, prefix.size(), prefix) != 0) break;
            std::size_t sep = i->first.find(getDelimiter(), prefix.size() + 1);
            if (sep == std::string::npos) {
                result.insert(result.end(),
                              i->first.substr(prefix.size() + 1, i->first.size() - prefix.size()));
            } else {
                result.insert(result.end(), i->first.substr(prefix.size() + 1, sep - prefix.size() - 1));
            }
        }
    } else {
        for (NameMap::const_iterator i = _names.lower_bound(prefix); i != _names.end(); ++i) {
            if (i->first.compare(0, prefix.size(), prefix) != 0) break;
            result.insert(result.end(),
                          i->first.substr(prefix.size() + 1, i->first.size() - prefix.size() - 1));
        }
    }
    return result;
}

getNonFlagFieldCount()

std::size_t lsst::afw::table::detail::SchemaImpl::getNonFlagFieldCount ( ) const

inline

The number of non-Flag fields.

Definition at line 75 of file SchemaImpl.h.

{ return _offsets.size(); }

getRecordSize()

std::size_t lsst::afw::table::detail::SchemaImpl::getRecordSize ( ) const

inline

The size of a record in bytes.

Definition at line 66 of file SchemaImpl.h.

{ return _recordSize; }

replaceField()

template<typename T >

void lsst::afw::table::detail::SchemaImpl::replaceField	(	Key< T > const &	key,
		Field< T > const &	field )

Replace the Field in an existing SchemaItem without changing the Key.

Definition at line 193 of file Schema.cc.

                                                                      {
    NameMap::iterator j = _names.find(field.getName());
    SchemaItem<T> *item = nullptr;
    if (j != _names.end()) {
        // The field name is already present in the Schema; see if it's the one we're replacing.
        // If we can get the old item with this, we don't need to update the name map at all.
        item = std::get_if<SchemaItem<T>>(&_items[j->second]);
        if (!item || key != item->key) {
            throw LSST_EXCEPT(
                    lsst::pex::exceptions::InvalidParameterError,
                    (boost::format("Field with name '%s' already present in schema with a different key.") %
                     field.getName())
                            .str());
        }
    }
    if (!item) {  // Need to find the original item by key, since it's a new name.
        std::size_t index = findKey(_offsets, _flags, key);
        item = std::get_if<SchemaItem<T>>(&_items[index]);
        if (!item) {
            throw LSST_EXCEPT(lsst::pex::exceptions::TypeError,
                              (boost::format("Incorrect key type '%s'.") % key).str());
        }
        j = _names.find(item->field.getName());
        _names.insert(j, std::pair<std::string, std::size_t>(field.getName(), j->second));
        _names.erase(j);
    }
    item->field = field;
}

Friends And Related Symbol Documentation

detail::Access

friend class detail::Access

friend

Definition at line 139 of file SchemaImpl.h.

Member Data Documentation

VERSION

int const lsst::afw::table::detail::SchemaImpl::VERSION = 3

static

Definition at line 52 of file SchemaImpl.h.

---

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/detail/SchemaImpl.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+53520f316c/src/table/Schema.cc