SchemaMapper.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef AFW_TABLE_SchemaMapper_h_INCLUDED
#define AFW_TABLE_SchemaMapper_h_INCLUDED

#include <memory>

#include "lsst/afw/table/detail/SchemaMapperImpl.h"

namespace lsst {
namespace afw {
namespace table {

class BaseRecord;

class SchemaMapper final {
public:
    Schema const getInputSchema() const { return _impl->_input; }

    Schema const getOutputSchema() const { return _impl->_output; }

    Schema& editOutputSchema() { return _impl->_output; }

    template <typename T>
    Key<T> addOutputField(Field<T> const& newField, bool doReplace = false) {
        return _impl->_output.addField(newField, doReplace);
    }

    template <typename T>
    Key<T> addMapping(Key<T> const& inputKey, bool doReplace = false);

    template <typename T>
    Key<T> addMapping(Key<T> const& inputKey, Field<T> const& outputField, bool doReplace = false);

    template <typename T>
    Key<T> addMapping(Key<T> const& inputKey, std::string const& outputName, bool doReplace = true);

    template <typename T>
    Key<T> addMapping(Key<T> const& inputKey, char const* outputName, bool doReplace = true) = delete;

    template <typename Predicate>
    void addMappingsWhere(Predicate predicate, bool doReplace = true);

    void addMinimalSchema(Schema const& minimal, bool doMap = true);

    static SchemaMapper removeMinimalSchema(Schema const& input, Schema const& minimal);

    void invert();

    template <typename T>
    bool isMapped(Key<T> const& inputKey) const;

    template <typename T>
    Key<T> getMapping(Key<T> const& inputKey) const;

    template <typename F>
    void forEach(F&& func) const {
        Impl::VisitorWrapper<F> visitor(std::forward<F>(func));
        std::for_each(_impl->_map.begin(), _impl->_map.end(), visitor);
    }

    explicit SchemaMapper();

    explicit SchemaMapper(Schema const& input, Schema const& output);

    explicit SchemaMapper(Schema const& input, bool shareAliasMap = false);

    SchemaMapper(SchemaMapper const& other);
    SchemaMapper(SchemaMapper&& other);

    SchemaMapper& operator=(SchemaMapper const& other);
    SchemaMapper& operator=(SchemaMapper&& other);

    ~SchemaMapper();

    static std::vector<SchemaMapper> join(
            std::vector<Schema> const& inputs,
            std::vector<std::string> const& prefixes = std::vector<std::string>());

private:
    template <typename Predicate>
    struct AddMappingsWhere {
        template <typename T>
        void operator()(SchemaItem<T> const& item) const {
            if (predicate(item)) mapper->addMapping(item.key, doReplace);
        }

        AddMappingsWhere(SchemaMapper* mapper_, Predicate predicate_, bool doReplace_)
                : mapper(mapper_), predicate(predicate_), doReplace(doReplace_) {}

        SchemaMapper* mapper;
        Predicate predicate;
        bool doReplace;
    };

    typedef detail::SchemaMapperImpl Impl;

    std::unique_ptr<Impl> _impl;
};

template <typename Predicate>
void SchemaMapper::addMappingsWhere(Predicate predicate, bool doReplace) {
    _impl->_input.forEach(AddMappingsWhere<Predicate>(this, predicate, doReplace));
}
}  // namespace table
}  // namespace afw
}  // namespace lsst

#endif  // !AFW_TABLE_SchemaMapper_h_INCLUDED