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

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

#include <SchemaImpl.h>

Classes
struct	VisitorWrapper
	A functor-wrapper used in the implementation of Schema::forEach. More...

Public Types
typedef boost::mpl::transform< FieldTypes, MakeItem >::type	ItemTypes
	An MPL sequence of all the allowed SchemaItem templates. More...
typedef boost::make_variant_over< ItemTypes >::type	ItemVariant
	A Boost.Variant type that can hold any one of the allowed SchemaItem types. More...
typedef std::vector< ItemVariant >	ItemContainer
	A std::vector whose elements can be any of the allowed SchemaItem types. More...
typedef std::map< std::string, int >	NameMap
	A map from field names to position in the vector, so we can do name lookups. More...
typedef std::map< int, int >	OffsetMap
	A map from standard field offsets to position in the vector, so we can do field lookups. More...
typedef std::map< std::pair< int, int >, int >	FlagMap
	A map from Flag field offset/bit pairs to position in the vector, so we can do Flag field lookups. More...

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

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 48 of file SchemaImpl.h.

Member Typedef Documentation

FlagMap

typedef std::map<std::pair<int, int>, int> lsst::afw::table::detail::SchemaImpl::FlagMap

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

Definition at line 72 of file SchemaImpl.h.

ItemContainer

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

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

Definition at line 66 of file SchemaImpl.h.

ItemTypes

typedef boost::mpl::transform<FieldTypes, MakeItem>::type lsst::afw::table::detail::SchemaImpl::ItemTypes

An MPL sequence of all the allowed SchemaItem templates.

Definition at line 62 of file SchemaImpl.h.

ItemVariant

typedef boost::make_variant_over<ItemTypes>::type lsst::afw::table::detail::SchemaImpl::ItemVariant

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

Definition at line 64 of file SchemaImpl.h.

NameMap

typedef std::map<std::string, int> lsst::afw::table::detail::SchemaImpl::NameMap

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

Definition at line 68 of file SchemaImpl.h.

OffsetMap

typedef std::map<int, int> lsst::afw::table::detail::SchemaImpl::OffsetMap

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

Definition at line 70 of file SchemaImpl.h.

Constructor & Destructor Documentation

SchemaImpl()

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

inlineexplicit

Default constructor.

Definition at line 146 of file SchemaImpl.h.

: _recordSize(0), _lastFlagField(-1), _lastFlagBit(-1), _items() {}

Member Function Documentation

addField() [1/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 504 of file Schema.cc.

                                                                 {
    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 508 of file Schema.cc.

                                                                       {
    static int const ELEMENT_SIZE = sizeof(Field<Flag>::Element);
    std::pair<NameMap::iterator, bool> result =
            _names.insert(std::pair<std::string, int>(field.getName(), _items.size()));
    if (!result.second) {
        if (doReplace) {
            SchemaItem<Flag> *item = boost::get<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 (_lastFlagField < 0 || _lastFlagBit >= ELEMENT_SIZE * 8) {
            int padding = ELEMENT_SIZE - _recordSize % ELEMENT_SIZE;
            if (padding != ELEMENT_SIZE) {
                _recordSize += padding;
            }
            _lastFlagField = _recordSize;
            _lastFlagBit = 0;
            _recordSize += field.getElementCount() * ELEMENT_SIZE;
        }
        SchemaItem<Flag> item(detail::Access::makeKey(_lastFlagField, _lastFlagBit), field);
        ++_lastFlagBit;
        _flags.insert(std::pair<std::pair<int, int>, int>(
                std::make_pair(item.key.getOffset(), item.key.getBit()), _items.size()));
        _items.push_back(item);
        return item.key;
    }
}

addField() [3/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 484 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() [4/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 493 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);
}

contains()

template<typename T >

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

Definition at line 415 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 = 0;
    int index = findKey(_offsets, _flags, item.key, false);
    if (index >= 0) {
        cmpItem = boost::get<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]

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 202 of file Schema.cc.

                                                          {
    NameMap::const_iterator i = _names.lower_bound(name);
    if (i != _names.end()) {
        if (i->first == name) {
            // got an exact match; we're done if it has the right type, and dead if it doesn't.
            try {
                return boost::get<SchemaItem<T> const>(_items[i->second]);
            } catch (boost::bad_get &err) {
                throw LSST_EXCEPT(lsst::pex::exceptions::TypeError,
                                  (boost::format("Field '%s' does not have the given type.") % name).str());
            }
        }
    }
    // We didn't get an exact match, but we might be searching for "a.x/a_x" and "a" might be a point field.
    // Because the names are sorted, we know we overshot it, so we work backwards.
    ExtractItemByName<T> extractor(name, getDelimiter());
    while (i != _names.begin()) {
        --i;
        boost::apply_visitor(extractor, _items[i->second]);  // see if the current item is a match
        if (extractor.result) return *extractor.result;
    }
    throw LSST_EXCEPT(lsst::pex::exceptions::NotFoundError,
                      (boost::format("Field or subfield with name '%s' not found with type '%s'.") % name %
                       Field<T>::getTypeString())
                              .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 289 of file Schema.cc.

                                                      {
    OffsetMap::const_iterator i = _offsets.lower_bound(key.getOffset());
    if (i != _offsets.end()) {
        if (i->first == key.getOffset()) {
            try {
                return boost::get<SchemaItem<T> const>(_items[i->second]);
            } catch (boost::bad_get &err) {
                // just swallow the exception; this might be a subfield key that points to the beginning.
            }
        }
        // We didn't get an exact match, but we might be searching for a subfield.
        // Because the offsets are sorted, we know we overshot it, so we work backwards.
        ExtractItemByKey<T> extractor(key, getDelimiter());
        while (i != _offsets.begin()) {
            --i;
            boost::apply_visitor(extractor, _items[i->second]);
            if (extractor.result) return *extractor.result;
        }
    }
    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]

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 315 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 boost::get<SchemaItem<Flag> const>(_items[i->second]);
            } catch (boost::bad_get &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());
            }
        }
    }
    // Flag keys are never subfields, so we require an exact match.
    throw LSST_EXCEPT(lsst::pex::exceptions::NotFoundError,
                      (boost::format("Flag field with offset %d and bit %d not found.") % key.getOffset() %
                       key.getBit())
                              .str());
}

findAndApply()

template<typename F >

void 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 99 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());
        }
        VisitorWrapper<F> visitor(std::forward<F>(func));
        visitor(_items[iter->second]);
    }

getFieldCount()

int lsst::afw::table::detail::SchemaImpl::getFieldCount ( ) const

inline

The total number of fields.

Definition at line 78 of file SchemaImpl.h.

{ return _names.size(); }

getFlagFieldCount()

int lsst::afw::table::detail::SchemaImpl::getFlagFieldCount ( ) const

inline

The number of Flag fields.

Definition at line 81 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 143 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 441 of file Schema.cc.

                                                         {
    std::set<std::string> result;
    if (topOnly) {
        for (NameMap::const_iterator i = _names.begin(); i != _names.end(); ++i) {
            std::size_t sep = i->first.find(getDelimiter());
            if (sep == std::string::npos) {
                result.insert(result.end(), i->first);
            } else {
                result.insert(result.end(), i->first.substr(0, sep));
            }
        }
    } else {
        for (NameMap::const_iterator i = _names.begin(); i != _names.end(); ++i) {
            result.insert(result.end(), i->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 460 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()

int lsst::afw::table::detail::SchemaImpl::getNonFlagFieldCount ( ) const

inline

The number of non-Flag fields.

Definition at line 84 of file SchemaImpl.h.

{ return _offsets.size(); }

getRecordSize()

int lsst::afw::table::detail::SchemaImpl::getRecordSize ( ) const

inline

The size of a record in bytes.

Definition at line 75 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 383 of file Schema.cc.

                                                                      {
    NameMap::iterator j = _names.find(field.getName());
    SchemaItem<T> *item = 0;
    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 = boost::get<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.
        int index = findKey(_offsets, _flags, key);
        item = boost::get<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, int>(field.getName(), j->second));
        _names.erase(j);
    }
    item->field = field;
}

Friends And Related Function Documentation

detail::Access

friend class detail::Access

friend

Definition at line 185 of file SchemaImpl.h.

Member Data Documentation

VERSION

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

static

Definition at line 59 of file SchemaImpl.h.

---

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

• /j/snowflake/release/lsstsw/stack/Linux64/afw/19.0.0-4-ga671dab3b+1/include/lsst/afw/table/detail/SchemaImpl.h
• /j/snowflake/release/lsstsw/stack/Linux64/afw/19.0.0-4-ga671dab3b+1/src/table/Schema.cc