SchemaMapper.h

Go to the documentation of this file.

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

#include "boost/scoped_ptr.hpp"

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

namespace lsst { namespace afw { namespace table {

class BaseRecord;

class SchemaMapper {
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 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<typename boost::unwrap_reference<F>::type &> visitor(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 & operator=(SchemaMapper const & other);

    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;

    boost::scoped_ptr<Impl> _impl;
};

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

}}} // namespace lsst::afw::table

#endif // !AFW_TABLE_SchemaMapper_h_INCLUDED