SchemaImpl.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef AFW_TABLE_DETAIL_SchemaImpl_h_INCLUDED
#define AFW_TABLE_DETAIL_SchemaImpl_h_INCLUDED
 
#include <vector>
#include <algorithm>
#include <map>
#include <variant>
 
namespace lsst {
namespace afw {
namespace table {
 
class Schema;
class SubSchema;
 
template <typename T>
struct SchemaItem final {
    Key<T> key;
    Field<T> field;
 
    SchemaItem(Key<T> const& key_, Field<T> const& field_) : key(key_), field(field_) {}
};
 
namespace detail {
 
class Access;
 
class SchemaImpl {
private:
    template <typename ...E>
    static std::variant<SchemaItem<E>...> makeItemVariantType(TypeList<E...>);
public:
    static int const VERSION = 3;
 
    using ItemVariant = decltype(makeItemVariantType(FieldTypes{}));
    using ItemContainer = std::vector<ItemVariant>;
    using NameMap = std::map<std::string, std::size_t>;
    using OffsetMap = std::map<std::size_t, std::size_t>;
    using FlagMap = std::map<std::pair<std::size_t, std::size_t>, std::size_t>;
 
    std::size_t getRecordSize() const { return _recordSize; }
 
    std::size_t getFieldCount() const { return _names.size(); }
 
    std::size_t getFlagFieldCount() const { return _flags.size(); }
 
    std::size_t getNonFlagFieldCount() const { return _offsets.size(); }
 
    template <typename T>
    SchemaItem<T> find(std::string const& name) const;
 
    template <typename T>
    SchemaItem<T> find(Key<T> const& key) const;
 
    SchemaItem<Flag> find(Key<Flag> const& key) const;
 
    template <typename F>
    decltype(auto) findAndApply(std::string const& name, F&& func) const {
        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]);
    }
 
    std::set<std::string> getNames(bool topOnly) const;
 
    std::set<std::string> getNames(bool topOnly, std::string const& prefix) const;
 
    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);
 
    Key<Flag> addField(Field<Flag> const& field, bool doReplace = false);
 
    template <typename T>
    Key<Array<T> > addField(Field<Array<T> > const& field, bool doReplace = false);
 
    Key<std::string> addField(Field<std::string> const& field, bool doReplace = false);
 
    template <typename T>
    void replaceField(Key<T> const& key, Field<T> const& field);
 
    ItemContainer const& getItems() const { return _items; }
 
    SchemaImpl() : _recordSize(0), _lastFlagField(0), _lastFlagBit(0), _items(), _initFlag(false) {}
 
private:
    friend class detail::Access;
 
    template <typename T>
    Key<T> addFieldImpl(std::size_t elementSize, std::size_t elementCount, Field<T> const& field, bool doReplace);
 
    std::size_t _recordSize;       // Size of a record in bytes.
    std::size_t _lastFlagField;    // Offset of the last flag field in bytes.
    std::size_t _lastFlagBit;      // Bit of the last flag field.
    ItemContainer _items;  // Vector of variants of SchemaItem<T>.
    NameMap _names;        // Field name to vector-index map.
    OffsetMap _offsets;    // Offset to vector-index map for regular fields.
    FlagMap _flags;        // Offset to vector-index map for flags.
    bool _initFlag;        // Indicates if record is valid
};
}  // namespace detail
}  // namespace table
}  // namespace afw
}  // namespace lsst
 
#endif  // !AFW_TABLE_DETAIL_SchemaImpl_h_INCLUDED