SchemaMapperImpl.h

Go to the documentation of this file.

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

#include <map>
#include <algorithm>

#include "boost/variant.hpp"
#include "boost/mpl/transform.hpp"

#include "lsst/afw/table/Schema.h"

namespace lsst {
namespace afw {
namespace table {

class SchemaMapper;

namespace detail {

class SchemaMapperImpl final {
private:
    struct MakeKeyPair {
        template <typename T>
        struct apply {
            typedef std::pair<Key<T>, Key<T> > type;
        };
    };

public:
    typedef boost::mpl::transform<FieldTypes, MakeKeyPair>::type KeyPairTypes;
    typedef boost::make_variant_over<KeyPairTypes>::type KeyPairVariant;
    typedef std::vector<KeyPairVariant> KeyPairMap;

    explicit SchemaMapperImpl(Schema const& input, Schema const& output) : _input(input), _output(output) {}

    template <typename F>
    struct VisitorWrapper : public boost::static_visitor<> {
        template <typename T>
        void operator()(std::pair<Key<T>, Key<T> > const& pair) const {
            _func(pair.first, pair.second);
        }

        void operator()(KeyPairVariant 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 table::SchemaMapper;
    friend class detail::Access;

    Schema _input;
    Schema _output;
    KeyPairMap _map;
};
}  // namespace detail
}  // namespace table
}  // namespace afw
}  // namespace lsst

#endif  // !AFW_TABLE_DETAIL_SchemaMapperImpl_h_INCLUDED