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 {
        for (auto const & item : _impl->_map) {
            std::visit([&func](auto const & pair) { func(pair.first, pair.second); }, item);
        }
    }
    template <typename F>
    void forEach(F const& func) const {
        for (auto const & item : _impl->_map) {
            std::visit([&func](auto const & pair) { func(pair.first, pair.second); }, item);
        }
    }
 
    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;
    };
 
    using Impl = detail::SchemaMapperImpl;
 
    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