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 <set>
 
#include "boost/variant.hpp"
#include "boost/mpl/transform.hpp"
 
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:
    struct MakeItem {
        template <typename T>
        struct apply {
            typedef SchemaItem<T> type;
        };
    };
 
public:
    static int const VERSION = 3;
 
    typedef boost::mpl::transform<FieldTypes, MakeItem>::type ItemTypes;
    typedef boost::make_variant_over<ItemTypes>::type ItemVariant;
    typedef std::vector<ItemVariant> ItemContainer;
    typedef std::map<std::string, int> NameMap;
    typedef std::map<int, int> OffsetMap;
    typedef std::map<std::pair<int, int>, int> FlagMap;
 
    int getRecordSize() const { return _recordSize; }
 
    int getFieldCount() const { return _names.size(); }
 
    int getFlagFieldCount() const { return _flags.size(); }
 
    int 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>
    void 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());
        }
        VisitorWrapper<F> visitor(std::forward<F>(func));
        visitor(_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; }
 
    explicit SchemaImpl() : _recordSize(0), _lastFlagField(-1), _lastFlagBit(-1), _items() {}
 
    template <typename F>
    struct VisitorWrapper : public boost::static_visitor<> {
        template <typename T>
        void operator()(SchemaItem<T> const& x) const {
            _func(x);
        };
 
        void operator()(ItemVariant const& v) const { boost::apply_visitor(*this, v); }
 
        template <typename T>
        explicit VisitorWrapper(T&& func) : _func(std::forward<T>(func)) {}
 
    private:
        F _func;
    };
 
private:
    friend class detail::Access;
 
    template <typename T>
    Key<T> addFieldImpl(int elementSize, int elementCount, Field<T> const& field, bool doReplace);
 
    int _recordSize;       // Size of a record in bytes.
    int _lastFlagField;    // Offset of the last flag field in bytes.
    int _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.
};
}  // namespace detail
}  // namespace table
}  // namespace afw
}  // namespace lsst
 
#endif  // !AFW_TABLE_DETAIL_SchemaImpl_h_INCLUDED