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