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