providerfor.hpp

Go to the documentation of this file.

/*
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
#ifndef PLASK__PROVIDERFOR_H
#define PLASK__PROVIDERFOR_H
 
#include "provider.hpp"
#include "../utils/stl.hpp"   // VariadicTemplateTypesHolder
 
#include "../mesh/transformed.hpp"
#include "../mesh/rectangular_spline.hpp"
 
namespace plask {
 
enum PropertyType {
    SINGLE_VALUE_PROPERTY = 0,          
    MULTI_VALUE_PROPERTY = 1,           
    FIELD_PROPERTY = 2,                 
    MULTI_FIELD_PROPERTY = 3            
};
 
template <PropertyType prop_type>
struct PropertyTypeToProviderName {
    static constexpr const char* value = "undefined";
};
 
template <>
struct PropertyTypeToProviderName<SINGLE_VALUE_PROPERTY> {
    static constexpr const char* value = "undefined value";
};
 
template <>
struct PropertyTypeToProviderName<MULTI_VALUE_PROPERTY> {
    static constexpr const char* value = "undefined value";
};
 
template <>
struct PropertyTypeToProviderName<FIELD_PROPERTY> {
    static constexpr const char* value = "undefined field";
};
 
template <>
struct PropertyTypeToProviderName<MULTI_FIELD_PROPERTY> {
    static constexpr const char* value = "undefined field";
};
 
template <PropertyType _propertyType, typename _ValueType2D, typename _ValueType3D, typename... _ExtraParams>
struct Property {
    static const PropertyType propertyType = _propertyType;
 
    typedef _ValueType2D ValueType2D;
 
    typedef _ValueType3D ValueType3D;
 
    static constexpr const char* NAME = PropertyTypeToProviderName<_propertyType>::value;
 
    static inline ValueType2D getDefaultValue2D() { return ValueType2D(); }
 
    static inline ValueType3D getDefaultValue3D() { return ValueType3D(); }
 
    typedef VariadicTemplateTypesHolder<_ExtraParams...> ExtraParams;
 
    static constexpr bool hasUniqueValueType = false;
 
};
 
template <PropertyType _propertyType, typename _ValueType, typename... _ExtraParams>
struct Property<_propertyType, _ValueType, _ValueType, _ExtraParams...> {
    static const PropertyType propertyType = _propertyType;
 
    typedef _ValueType ValueType;
 
    typedef _ValueType ValueType2D;
 
    typedef _ValueType ValueType3D;
 
    static constexpr const char* NAME = PropertyTypeToProviderName<_propertyType>::value;
 
    static inline ValueType getDefaultValue() { return ValueType(); }
 
    typedef VariadicTemplateTypesHolder<_ExtraParams...> ExtraParams;
 
    static constexpr bool hasUniqueValueType = true;
 
    static const ValueType2D& value3Dto2D(const ValueType3D& v) { return v; }
 
    static const ValueType3D& value2Dto3D(const ValueType2D& v) { return v; }
 
    static const ValueType2D& value3Dto2Dcyl(const ValueType3D& v, const Vec<3, double>&) { return v; }
 
    static const ValueType3D& value2Dto3Dcyl(const ValueType2D& v, const Vec<3, double>&) { return v; }
};
 
 
template <typename PropertyTag, int DIM, bool hasUniqueValueType>
struct PropertyAtDimImpl {};
 
template <typename PropertyTag>
struct PropertyAtDimImpl<PropertyTag, 2, true> {
    typedef typename PropertyTag::ValueType2D ValueType;
 
    static ValueType getDefaultValue() { return PropertyTag::getDefaultValue(); }
 
    template <typename MeshT>
    static LazyData<ValueType> convertLazyData(const LazyData<ValueType>& src, const shared_ptr<MeshT>&) { return src; }
};
 
template <typename PropertyTag>
struct PropertyAtDimImpl<PropertyTag, 2, false> {
    typedef typename PropertyTag::ValueType2D ValueType;
 
    static ValueType getDefaultValue() { return PropertyTag::getDefaultValue2D(); }
 
    static LazyData<ValueType> convertLazyData(const LazyData<ValueType>& src) { return src; }
 
    template <typename MeshT>
    static LazyData<ValueType> convertLazyData(const LazyData<typename PropertyTag::ValueType3D>& src, const shared_ptr<MeshT>&) {
        return LazyData<ValueType>(src.size(), [src](std::size_t i) { return PropertyTag::value3Dto2D(src[i]); });
    }
};
 
template <typename PropertyTag>
struct PropertyAtDimImpl<PropertyTag, 3, true> {
    typedef typename PropertyTag::ValueType3D ValueType;
 
    static ValueType getDefaultValue() { return PropertyTag::getDefaultValue(); }
 
    template <typename MeshT>
    static LazyData<ValueType> convertLazyData(const LazyData<ValueType>& src, const shared_ptr<MeshT>&) { return src; }
};
 
template <typename PropertyTag>
struct PropertyAtDimImpl<PropertyTag, 3, false> {
    typedef typename PropertyTag::ValueType3D ValueType;
 
    static ValueType getDefaultValue() { return PropertyTag::getDefaultValue3D(); }
 
    static LazyData<ValueType> convertLazyData(const LazyData<ValueType>& src) { return src; }
 
    template <typename MeshT>
    static LazyData<ValueType> convertLazyData(const LazyData<typename PropertyTag::ValueType2D>& src, const shared_ptr<MeshT>&) {
        return LazyData<ValueType>(src.size(), [src](std::size_t i) { return PropertyTag::value2Dto3D(src[i]); });
    }
};
 
template <typename PropertyTag, int dim>
using PropertyAtDim = PropertyAtDimImpl<PropertyTag, dim, PropertyTag::hasUniqueValueType>;
 
 
template <typename PropertyTag, typename Space, typename SrcSpace, bool hasUniqueValueType>
struct PropertyAtImpl: public PropertyAtDimImpl<PropertyTag, Space::DIM, hasUniqueValueType> {};
 
template <typename PropertyTag>
struct PropertyAtImpl<PropertyTag, Geometry3D, Geometry2DCylindrical, false>: public PropertyAtDimImpl<PropertyTag, 3, false> {
    typedef typename PropertyTag::ValueType3D ValueType;
 
    static LazyData<ValueType> convertLazyData(const LazyData<typename PropertyTag::ValueType2D>& src, const shared_ptr<CylReductionTo2DMesh>& mesh) {
        return LazyData<ValueType>(src.size(), [src, mesh](std::size_t i) { return PropertyTag::value2Dto3Dcyl(src[i], mesh->rVector(i)); });
    }
};
 
template <typename PropertyTag>
struct PropertyAtImpl<PropertyTag, Geometry2DCylindrical, Geometry3D, false>: public PropertyAtDimImpl<PropertyTag, 2, false> {
    typedef typename PropertyTag::ValueType2D ValueType;
 
    static LazyData<ValueType> convertLazyData(const LazyData<typename PropertyTag::ValueType3D>& src, const shared_ptr<PointsOnCircleMeshExtend>& mesh) {
        return LazyData<ValueType>(src.size(), [src, mesh](std::size_t i) { return PropertyTag::value3Dto2Dcyl(src[i], mesh->rVector(i)); });
    }
};
template <typename PropertyTag, typename Space, typename SrcSpace = void>
struct PropertyAt: public PropertyAtImpl<PropertyTag, Space, SrcSpace, PropertyTag::hasUniqueValueType> {};
 
template <typename PropertyTag>
struct PropertyAt<PropertyTag, void>: public PropertyAtDim<PropertyTag, 2> {
    static_assert(PropertyTag::hasUniqueValueType, "Space was not given in PropertyAt for property which has different types of values in 2D and 3D.");
};
 
 
template<typename ValueT=double, typename... _ExtraParams>
struct SingleValueProperty: public Property<SINGLE_VALUE_PROPERTY, ValueT, ValueT, _ExtraParams...> {};
 
template<typename ValueT=double, typename... _ExtraParams>
struct MultiValueProperty: public Property<MULTI_VALUE_PROPERTY, ValueT, ValueT, _ExtraParams...> {
    typedef size_t EnumType;
};
 
template<typename ValueT=double, typename... _ExtraParams>
struct FieldProperty: public Property<FIELD_PROPERTY, ValueT, ValueT, _ExtraParams...> {};
 
template<typename ValueT = double, typename... _ExtraParams>
struct MultiFieldProperty: public Property<MULTI_FIELD_PROPERTY, ValueT, ValueT, _ExtraParams...> {
    typedef size_t EnumType;
};
 
template<typename ValueT_2D, typename ValueT_3D, typename... _ExtraParams>
struct CustomFieldProperty: public Property<FIELD_PROPERTY, ValueT_2D, ValueT_3D, _ExtraParams...> {};
 
template<typename ValueT_2D, typename ValueT_3D, typename... _ExtraParams>
struct MultiCustomFieldProperty: public Property<MULTI_FIELD_PROPERTY, ValueT_2D, ValueT_3D, _ExtraParams...> {
    typedef size_t EnumType;
};
 
template<typename ValueT = double, typename... _ExtraParams>
struct VectorFieldProperty: public Property<FIELD_PROPERTY, Vec<2, ValueT>, Vec<3, ValueT>, _ExtraParams...> {
 
    static Vec<2, ValueT> value3Dto2D(const Vec<3, ValueT>& v) { return vec<2>(v); }
 
    static Vec<3, ValueT> value2Dto3D(const Vec<2, ValueT>& v) { return vec(v, ValueT()); }
 
    static const Vec<2, ValueT> value3Dto2Dcyl(const Vec<3, ValueT>& v, const Vec<3, double>& p) {
        // v * p / |p|, v.c2
        return vec(::plask::fma(v.c0, p.c0, v.c1 * p.c1) / std::hypot(p.c0, p.c1), v.c2);
    }
 
    static const Vec<3, ValueT> value2Dto3Dcyl(const Vec<2, ValueT>& v, const Vec<3, double>& p) {
        double r = std::hypot(p.c0, p.c1);
        return vec(v.c0 * p.c0/r, v.c0 * p.c1/r, v.c1);
    }
};
 
template<typename ValueT = double, typename... _ExtraParams>
struct MultiVectorFieldProperty: public Property<MULTI_FIELD_PROPERTY, Vec<2, ValueT>, Vec<3, ValueT>, _ExtraParams...> {
 
    typedef size_t EnumType;
 
    static Vec<2, ValueT> value3Dto2D(const Vec<3, ValueT>& v) { return vec<2>(v); }
 
    static Vec<3, ValueT> value2Dto3D(const Vec<2, ValueT>& v) { return vec(v, ValueT()); }
};
 
typedef FieldProperty<double> ScalarFieldProperty;
 
typedef MultiFieldProperty<double> MultiScalarFieldProperty;
 
 
 
 
 
template <typename PropertyT, PropertyType propertyType, typename spaceType, typename VariadicTemplateTypesHolder>
struct ProviderImpl {};
 
template <typename PropertyT, typename SpaceT = void>
struct ProviderFor: public ProviderImpl<PropertyT, PropertyT::propertyType, SpaceT, typename PropertyT::ExtraParams> {
 
    typedef PropertyT PropertyTag;
    typedef SpaceT SpaceType;
 
    template<typename ...Args>
    ProviderFor(Args&&... params)
    : ProviderImpl<PropertyT, PropertyT::propertyType, SpaceT, typename PropertyT::ExtraParams>(std::forward<Args>(params)...) {
    }
 
};
//TODO redefine ProviderFor using template aliases (does not work with GCC)
//template <typename PropertyT, typename SpaceT = void>
//using ProviderFor = ProviderImpl<PropertyT, PropertyT::propertyType, SpaceT, typename PropertyT::ExtraParams>;
 
 
 
 
template <typename PropertyT, typename SpaceT = void>
struct ReceiverFor: public Receiver<ProviderImpl<PropertyT, PropertyT::propertyType, SpaceT, typename PropertyT::ExtraParams>> {
    ReceiverFor & operator=(const ReceiverFor&) = delete;
    ReceiverFor(const ReceiverFor&) = delete;
    ReceiverFor() = default;
 
    typedef PropertyT PropertyTag;
    typedef SpaceT SpaceType;
    typedef typename PropertyAt<PropertyT, SpaceT>::ValueType ValueType;
 
    ReceiverFor<PropertyT, SpaceT>& operator=(const ValueType& v) {
        this->setConstValue(v);
        return *this;
    }
 
    template <typename... Args, PropertyType propertyType = PropertyTag::propertyType>
    typename std::enable_if<propertyType == SINGLE_VALUE_PROPERTY>::type
    setValue(Args&&... value) {
        this->setProvider(new typename ProviderFor<PropertyTag>::WithValue(std::forward<Args>(value)...), true);
    }
 
    template <typename... Args, PropertyType propertyType = PropertyTag::propertyType>
    typename std::enable_if<propertyType == MULTI_VALUE_PROPERTY>::type
    setValue(const ValueType& value) {
        this->setProvider(new typename ProviderFor<PropertyTag>::WithValue(value), true);
    }
 
    template <typename... Args, PropertyType propertyType = PropertyTag::propertyType>
    typename std::enable_if<propertyType == MULTI_VALUE_PROPERTY>::type
    setValues(Args&&... value) {
        this->setProvider(new typename ProviderFor<PropertyTag>::WithValue(std::forward<Args>(value)...), true);
    }
 
    template <typename MeshT, PropertyType propertyType = PropertyTag::propertyType>
    typename std::enable_if<propertyType == FIELD_PROPERTY || propertyType == MULTI_FIELD_PROPERTY>::type
    setValue(DataVector<const ValueType> data, shared_ptr<MeshT> mesh) {
        if (data.size() != mesh->size())
            throw BadMesh("receiverFor::setValues()", "Mesh size ({1}) and data size ({0}) do not match", data.size(), mesh->size());
        this->setProvider(new typename ProviderFor<PropertyTag, SpaceType>::template WithValue<MeshT>(data, mesh), true);
    }
 
    template <typename Iterator, PropertyType propertyType = PropertyTag::propertyType>
    typename std::enable_if<propertyType == MULTI_FIELD_PROPERTY>::type
    setValues(Iterator begin, Iterator end) {
        this->setProvider(new typename ProviderFor<PropertyTag, SpaceType>::ConstProviderType(begin, end), true);
    }
 
    template <typename MeshT, typename Iterator, PropertyType propertyType = PropertyTag::propertyType>
    typename std::enable_if<propertyType == MULTI_FIELD_PROPERTY>::type
    setValues(Iterator begin, Iterator end, shared_ptr<MeshT> mesh) {
        size_t i = 0;
        for (Iterator it = begin; it != end; ++it, ++i )
            if (*it.size() != mesh->size())
                throw BadMesh("receiverFor::setValues()", "Mesh size ({1}) and data[{2}] size ({0}) do not match", it->size(), mesh->size(), i);
        this->setProvider(new typename ProviderFor<PropertyTag, SpaceType>::template WithValue<MeshT>(begin, end, mesh), true);
    }
 
    template <typename MeshT, PropertyType propertyType = PropertyTag::propertyType>
    typename std::enable_if<propertyType == MULTI_FIELD_PROPERTY>::type
    setValue(const std::vector<DataVector<const ValueType>>& data, shared_ptr<MeshT> mesh) {
        for (auto it = data.begin(); it != data.end(); ++it)
            if (it->size() != mesh->size())
                throw BadMesh("receiverFor::setValues()", "Mesh size ({1}) and data[{2}] size ({0}) do not match", it->size(), mesh->size(), it-data.begin());
        this->setProvider(new typename ProviderFor<PropertyTag, SpaceType>::template WithValue<MeshT>(data.begin(), data.end(), mesh), true);
    }
 
    template <typename GeometryT = SpaceT>
    typename std::enable_if<std::is_same<GeometryT, Geometry3D>::value>::type
    setTransformedProvider(ProviderFor<PropertyT, Geometry2DCartesian>* provider) {
        this->setProvider(new typename ProviderFor<PropertyT, GeometryT>::template Transform<ReductionTo2DMesh>(provider), true);
    }
 
    template <typename GeometryT = SpaceT>
    typename std::enable_if<std::is_same<GeometryT, Geometry3D>::value>::type
    setTransformedProvider(ProviderFor<PropertyT, Geometry2DCylindrical>* provider) {
        this->setProvider(new typename ProviderFor<PropertyT, GeometryT>::template Transform<CylReductionTo2DMesh>(provider), true);
    }
 
    template <typename GeometryT = SpaceT>
    typename std::enable_if<std::is_same<GeometryT, Geometry2DCartesian>::value>::type
    setTransformedProvider(ProviderFor<PropertyT, Geometry3D>* provider) {
        this->setProvider(new typename ProviderFor<PropertyT, GeometryT>::template Transform<CartesianMesh2DTo3D>(provider), true);
    }
 
    template <typename GeometryT = SpaceT>
    typename std::enable_if<std::is_same<GeometryT, Geometry2DCylindrical>::value>::type
    setTransformedProvider(ProviderFor<PropertyT, Geometry3D>* provider) {
        this->setProvider(new typename ProviderFor<PropertyT, GeometryT>::template Transform<PointsOnCircleMeshExtend>(provider), true);
    }
 
    template <PropertyType propertyType = PropertyTag::propertyType>
    typename std::enable_if<propertyType == MULTI_VALUE_PROPERTY || propertyType == MULTI_FIELD_PROPERTY, size_t>::type
    size() const {
        this->ensureHasProvider();
        return this->provider->size();
    }
 
    static_assert(!(std::is_same<SpaceT, void>::value && (PropertyT::propertyType == FIELD_PROPERTY || PropertyT::propertyType == MULTI_FIELD_PROPERTY)),
                  "Receivers for fields properties require SpaceT. Use ReceiverFor<propertyTag, SpaceT>, where SpaceT is one of the classes defined in <plask/geometry/space.h>.");
    static_assert(!(!std::is_same<SpaceT, void>::value && (PropertyT::propertyType == SINGLE_VALUE_PROPERTY || PropertyT::propertyType == MULTI_VALUE_PROPERTY)),
                  "Receivers for single value properties doesn't need SpaceT. Use ReceiverFor<propertyTag> (without second template parameter).");
 
    //    * Set provider to of derived type
    //    * \param provider new provider
    //    */
    //template <typename OtherProvidersT>
    //void setProvider(OtherProviderT* provider) {
    //    auto provider = new ProviderFor<OtherProviderT::PropertyTag>::Delegate([&provider](){})
    //}
 
};
//struct ReceiverFor: public Receiver< ProviderFor<PropertyT> > {};
 
template <typename PropertyT, typename SpaceT, typename... _ExtraParams>
struct ProviderImpl<PropertyT, SINGLE_VALUE_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...> >: public SingleValueProvider<typename PropertyAt<PropertyT, SpaceT>::ValueType, _ExtraParams...> {
 
    typedef PropertyT PropertyTag;
    typedef SpaceT SpaceType;
 
    static constexpr const char* NAME = PropertyT::NAME;
    const char* name() const override { return NAME; }
 
    static_assert(std::is_same<SpaceT, void>::value,
                  "Providers for single value properties doesn't need SpaceT. Use ProviderFor<propertyTag> (without second template parameter).");
 
    typedef typename PropertyAt<PropertyT, SpaceT>::ValueType ValueType;
 
    typedef typename SingleValueProvider<ValueType>::ProvidedType ProvidedType;
 
    struct WithDefaultValue: public ProviderFor<PropertyT, SpaceT> {
 
        typedef ValueType ProvidedType;
 
        ProvidedType value;
 
        template<typename ...Args>
        WithDefaultValue(Args&&... params): value(std::forward<Args>(params)...) {}
 
        WithDefaultValue& operator=(const ValueType& v) {
            value = v;
            return *this;
        }
 
        ProvidedType operator()(_ExtraParams...) const override { return value; }
    };
 
    struct WithValue: public ProviderFor<PropertyT, SpaceT> {
 
        typedef ValueType ProvidedType;
 
        plask::optional<ProvidedType> value;
 
        void invalidate() { value.reset(); }
 
        bool hasValue() const { return bool(value); }
 
        void ensureHasValue() const {
            if (!hasValue()) throw NoValue(NAME);
        }
 
        WithValue(const ProvidedType& value): value(value) {}
 
        WithValue(ProvidedType&& value): value(value) {}
 
        WithValue() {}
 
        WithValue& operator=(const ValueType& v) {
            value.reset(v);
            return *this;
        }
 
        ProvidedType operator()(_ExtraParams...) const override {
            ensureHasValue();
            return *value;
        }
    };
 
    typedef PolymorphicDelegateProvider<ProviderFor<PropertyT, SpaceT>, ProvidedType(_ExtraParams...)> Delegate;
 
    typedef WithValue ConstProviderType;
 
};
 
template <typename PropertyT, typename SpaceT, typename... _ExtraParams>
struct ProviderImpl<PropertyT, MULTI_VALUE_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...> >: public MultiValueProvider<typename PropertyAt<PropertyT, SpaceT>::ValueType, typename PropertyT::EnumType, _ExtraParams...> {
 
    typedef PropertyT PropertyTag;
    typedef SpaceT SpaceType;
 
    typedef typename PropertyT::EnumType EnumType;
 
    static constexpr const char* NAME = PropertyT::NAME;
    const char* name() const override { return NAME; }
 
    static_assert(std::is_same<SpaceT, void>::value,
                  "Providers for single value properties doesn't need SpaceT. Use ProviderFor<propertyTag> (without second template parameter).");
 
    typedef typename PropertyAt<PropertyT, SpaceT>::ValueType ValueType;
 
    typedef typename MultiValueProvider<ValueType, EnumType>::ProvidedType ProvidedType;
 
    struct WithDefaultValue: public ProviderFor<PropertyT, SpaceT> {
 
        typedef ValueType ProvidedType;
 
        ProvidedType default_value;
 
        std::vector<ProvidedType> values;
 
        WithDefaultValue(const std::initializer_list<ProvidedType>& values, const ProvidedType& defval=ProvidedType()): default_value(defval), values(values) {}
 
        template <typename Iterator>
        explicit WithDefaultValue(const Iterator& begin, const Iterator& end, const ProvidedType& defval=ProvidedType()): default_value(defval), values(begin, end) {}
 
        WithDefaultValue(const ProvidedType& defval=ProvidedType()): default_value(defval) {}
 
        ProvidedType& operator[](size_t n) {
            size_t n0 = values.size();
            if (n > n0) {
                values.resize(n);
                for (size_t i = n0; i != n; ++i) values[i] = default_value;
            }
            return values[n];
        }
 
        void resize(size_t n) {
            size_t n0 = values.size();
            values.resize(n);
            if (n > n0) {
                for (size_t i = n0; i != n; ++i) values[i] = default_value;
            }
        }
 
        size_t size() const override {
            return values.size();
        }
 
        ProvidedType operator()(EnumType num, _ExtraParams...) const override {
            size_t n(num);
            if (n > values.size()) return default_value;
            return values[n];
        }
    };
 
    struct WithValue: public ProviderFor<PropertyT, SpaceT> {
 
        typedef ValueType ProvidedType;
 
        std::vector<ProvidedType> values;   //TODO powinien trzymać DataVectory
 
        void invalidate() { values.clear(); }
 
        void ensureIndex(size_t n) const {
            if (n >= values.size()) throw NoValue(NAME);
        }
 
        explicit WithValue(const ProvidedType& value): values({value}) {}
 
        explicit WithValue(ProvidedType&& value): values({value}) {}
 
        WithValue(const std::initializer_list<ProvidedType>& values): values(values) {}
 
        template <typename Iterator>
        explicit WithValue(const Iterator& begin, const Iterator& end): values(begin, end) {}
 
        WithValue() {}
 
        ProvidedType& operator[](size_t n) {
            if (n > values.size()) throw BadInput(NAME, "Wrong value index");
            return values[n];
        }
 
        void push_back(const ProvidedType& value) {
            values.push_back(value);
        }
 
        template <typename... Args>
        void emplate_back(Args&&... args) {
            values.emplace_back(std::forward<Args>(args)...);
        }
 
        size_t size() const override {
            return values.size();
        }
 
        ProvidedType operator()(EnumType n, _ExtraParams...) const override {
            ensureIndex(n);
            return values[n];
        }
    };
 
    struct Delegate: public PolymorphicDelegateProvider<ProviderFor<PropertyT, SpaceT>, ProvidedType(EnumType, _ExtraParams...)> {
 
        typedef PolymorphicDelegateProvider<ProviderFor<PropertyT, SpaceT>, ProvidedType(EnumType, _ExtraParams...)> Base;
 
        std::function<size_t()> sizeGetter;
 
        template<typename Functor, typename Sizer>
        Delegate(Functor functor, Sizer sizer): Base(functor), sizeGetter(sizer) {}
 
        template<typename ClassType, typename MemberType>
        Delegate(ClassType* object, MemberType member, size_t (ClassType::*sizer)()const): Base(object, member),
            sizeGetter([object, sizer]() { return (object->*sizer)(); }) {}
 
        template<typename ClassType, typename MemberType>
        Delegate(ClassType* object, MemberType member, size_t (ClassType::*sizer)()): Base(object, member),
            sizeGetter([object, sizer]() { return (object->*sizer)(); }) {}
 
        template<typename Functor>
        Delegate(Functor functor): Base(functor), sizeGetter([]{return PropertyT::NUM_VALS;}) {}
 
        template<typename ClassType, typename MemberType>
        Delegate(ClassType* object, MemberType member): Base(object, member), sizeGetter([]{return PropertyT::NUM_VALS;}) {}
 
        size_t size() const override {
            return sizeGetter();
        }
 
    };
 
    typedef WithValue ConstProviderType;
 
};
 
template <typename PropertyT, typename SpaceT, typename... _ExtraParams>
struct ProviderImpl<PropertyT, FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...> >: public FieldProvider<typename PropertyAt<PropertyT, SpaceT>::ValueType, SpaceT, _ExtraParams...> {
 
    typedef PropertyT PropertyTag;
    typedef SpaceT SpaceType;
 
    static constexpr const char* NAME = PropertyT::NAME;
    const char* name() const override { return NAME; }
 
    static_assert(!std::is_same<SpaceT, void>::value,
                  "Providers for fields properties require SpaceT. Use ProviderFor<propertyTag, SpaceT>, where SpaceT is one of the class defined in plask/geometry/space.h.");
 
    typedef typename PropertyAt<PropertyT, SpaceT>::ValueType ValueType;
 
    typedef typename FieldProvider<ValueType, SpaceT>::ProvidedType ProvidedType;
 
    template <typename MeshType>
    struct WithValue: public ProviderFor<PropertyT, SpaceT> {
 
        typedef shared_ptr<MeshType> MeshPointerType;
 
        typedef typename ProviderImpl<PropertyT, FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...> >::ProvidedType ProvidedType;
 
        typedef DataVector<const ValueType> HeldType;
 
        HeldType values;
 
      protected:
 
        MeshPointerType mesh_ptr;
 
        InterpolationMethod default_interpolation;
 
      public:
 
        auto getMesh() -> decltype(*mesh_ptr) { return *mesh_ptr; }
 
        auto getMesh() const -> decltype(*mesh_ptr) { return *mesh_ptr; }
 
        void setMesh(MeshPointerType mesh_p) {
            if (mesh_ptr) mesh_ptr->changedDisconnectMethod(this, &ProviderImpl<PropertyT, FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...> >::WithValue<MeshType>::onMeshChange);
            mesh_ptr = mesh_p;
            mesh_ptr->changedConnectMethod(this, &ProviderImpl<PropertyT, FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...>>::WithValue<MeshType>::onMeshChange);
        }
 
        void invalidate() { values.reset(); }
 
        void allocate() { values.reset(mesh_ptr->size); }
 
        bool hasValue() const { return values.data() != nullptr; }
 
        void ensureHasValue() const {
            if (!hasValue()) throw NoValue(this->name());
        }
 
        bool hasCorrectValue() const { return hasValue() && values.size() == mesh_ptr->size(); }
 
        void ensureHasCorrectValue() const {
            if (!hasValue()) throw NoValue(this->name());
            if (values.size() != mesh_ptr->size())
                throw BadMesh("provider::WithValue", "Mesh size ({1}) and values size ({0}) do not match", values.size(), mesh_ptr->size());
        }
 
        void onMeshChange(const Mesh::Event& PLASK_UNUSED(evt)) {
            this->invalidate();
        }
 
 
        explicit WithValue(HeldType values, MeshPointerType mesh_ptr = nullptr, InterpolationMethod default_interpolation = INTERPOLATION_LINEAR)
            : values(values), mesh_ptr(mesh_ptr), default_interpolation(default_interpolation) {
            if (mesh_ptr) mesh_ptr->changedConnectMethod(this, &ProviderImpl<PropertyT, FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...>>::WithValue<MeshType>::onMeshChange);
        }
 
        explicit WithValue(MeshPointerType mesh_ptr = nullptr, const InterpolationMethod& default_interpolation = INTERPOLATION_LINEAR)
            : mesh_ptr(mesh_ptr), default_interpolation(default_interpolation) {
            if (mesh_ptr) mesh_ptr->changedConnectMethod(this, &ProviderImpl<PropertyT, FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...>>::WithValue<MeshType>::onMeshChange);
        }
 
        ~WithValue() {
            if (mesh_ptr) mesh_ptr->changedDisconnectMethod(this, &ProviderImpl<PropertyT, FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...> >::WithValue<MeshType>::onMeshChange);
        }
 
        ProvidedType& operator()() {
            ensureHasCorrectValue();
            return values;
        }
 
        const ProvidedType& operator()() const {
            ensureHasCorrectValue();
            return values;
        }
 
        ProvidedType operator()(shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, _ExtraParams..., InterpolationMethod method = INTERPOLATION_DEFAULT) const override {
            ensureHasCorrectValue();
            if (method == INTERPOLATION_DEFAULT) method = default_interpolation;
            return interpolate(mesh_ptr, values, dst_mesh, method);
        }
    };
 
    template <typename MeshTransform>
    struct Transform: public ProviderFor<PropertyT, SpaceT> {
 
        static_assert(std::is_same<SpaceT, typename MeshTransform::SourceGeometry>::value, "Bad transform source mesh type");
 
        typedef typename ProviderImpl<PropertyT, FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...> >::ProvidedType ProvidedType;
 
        ReceiverFor<PropertyT, typename MeshTransform::TargetGeometry> receiver;
 
        Transform() {
            receiver.changedConnectMethod(this, &Transform::_receiverChanged);
        }
 
        Transform(ProviderFor<PropertyT, typename MeshTransform::TargetGeometry>* provider) {
            receiver.changedConnectMethod(this, &Transform::_receiverChanged);
            receiver.setProvider(provider);
        }
 
        ~Transform() {
            receiver.changedDisconnectMethod(this, &Transform::_receiverChanged);
        }
 
        ProvidedType operator()(shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, _ExtraParams...params, InterpolationMethod method = INTERPOLATION_DEFAULT) const override {
            auto trans_mesh(make_shared<MeshTransform>(dst_mesh));
            return PropertyAt<PropertyT, SpaceT, typename MeshTransform::TargetGeometry>::convertLazyData(receiver(trans_mesh, params..., method), trans_mesh);
        }
 
      private:
 
         void _receiverChanged(ReceiverBase&, ReceiverBase::ChangeReason) {
             this->fireChanged();
         }
 
    };
 
    typedef PolymorphicDelegateProvider<ProviderFor<PropertyT, SpaceT>, ProvidedType(shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, _ExtraParams..., InterpolationMethod method)> Delegate;
 
    struct ConstProviderType: public ProviderFor<PropertyT, SpaceT> {
 
        typedef typename ProviderImpl<PropertyT, FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...>>::ProvidedType ProvidedType;
 
        ValueType value;
 
        //ConstProviderType(const ValueT& value): value(value) {}
 
        template<typename ...Args>
        ConstProviderType(Args&&... params): value(std::forward<Args>(params)...) {}
 
        ProvidedType operator()(shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, _ExtraParams..., InterpolationMethod) const override {
            return ProvidedType(dst_mesh->size(), value);
        }
    };
};
 
template <typename PropertyT, typename SpaceT, typename... _ExtraParams>
struct ProviderImpl<PropertyT, MULTI_FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...> >: public MultiFieldProvider<typename PropertyAt<PropertyT, SpaceT>::ValueType, SpaceT, typename PropertyT::EnumType, _ExtraParams...> {
 
    typedef PropertyT PropertyTag;
    typedef SpaceT SpaceType;
 
    typedef typename PropertyT::EnumType EnumType;
 
    static constexpr const char* NAME = PropertyT::NAME;
    const char* name() const override { return NAME; }
 
    static_assert(!std::is_same<SpaceT, void>::value,
                  "Providers for fields properties require SpaceT. Use ProviderFor<propertyTag, SpaceT>, where SpaceT is one of the class defined in plask/geometry/space.h.");
 
    typedef typename PropertyAt<PropertyT, SpaceT>::ValueType ValueType;
 
    typedef typename MultiFieldProvider<ValueType, SpaceT, EnumType>::ProvidedType ProvidedType;
 
    template <typename MeshType>
    struct WithValue: public ProviderFor<PropertyT, SpaceT> {
 
        typedef shared_ptr<MeshType> MeshPointerType;
 
        typedef typename ProviderImpl<PropertyT, MULTI_FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...> >::ProvidedType ProvidedType;
 
        typedef DataVector<const ValueType> HeldType;
 
        std::vector<HeldType> values;
 
      protected:
 
        MeshPointerType mesh_ptr;
 
        InterpolationMethod default_interpolation;
 
      public:
 
        auto getMesh() -> decltype(*mesh_ptr) { return *mesh_ptr; }
 
        auto getMesh() const -> decltype(*mesh_ptr) { return *mesh_ptr; }
 
        void setMesh(MeshPointerType mesh_p) {
            if (mesh_ptr) mesh_ptr->changedDisconnectMethod(this, &ProviderImpl<PropertyT, MULTI_FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...> >::WithValue<MeshType>::onMeshChange);
            mesh_ptr = mesh_p;
            mesh_ptr->changedConnectMethod(this, &ProviderImpl<PropertyT, MULTI_FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...>>::WithValue<MeshType>::onMeshChange);
        }
 
        void invalidate() { values.clear(); }
 
        void allocate(size_t num) {
            values.resize(num);
            for (auto& val: values) val.reset(mesh_ptr->size);
        }
 
        void push_back(const HeldType& value) {
            values.push_back(value);
        }
 
        size_t size() const override {
            return values.size();
        }
 
        bool hasCorrectValue(size_t n) const {
            return n < values.size() && values[n].size() = mesh_ptr->size();
        }
 
        bool hasCorrectValues() const {
            if (values.size() == 0) return false;
            for (const auto& val: values)
                if (val.size() != mesh_ptr->size()) return false;
            return true;
        }
 
        void ensureHasCorrectValue(size_t n) const {
            if (n >= values.size()) throw NoValue(this->name());
            if (values[n].size() != mesh_ptr->size())
                    throw BadMesh("provider::WithValue", "Mesh size ({1}) and values[{2}] size ({0}) do not match", values.size(), mesh_ptr->size(), n);
        }
 
        void ensureHasCorrectValues() const {
            if (values.size() == 0) throw NoValue(this->name());
            for (size_t i = 0; i != values.size(); ++i)
                if (values[i].size() != mesh_ptr->size())
                    throw BadMesh("provider::WithValue", "Mesh size ({1}) and values[{2}] size ({0}) do not match", values.size(), mesh_ptr->size(), i);
        }
 
        void onMeshChange(const Mesh::Event& PLASK_UNUSED(evt)) {
            this->invalidate();
        }
 
 
        explicit WithValue(HeldType values, MeshPointerType mesh_ptr = nullptr, InterpolationMethod default_interpolation = INTERPOLATION_LINEAR)
            : values({values}), mesh_ptr(mesh_ptr), default_interpolation(default_interpolation) {
            if (mesh_ptr) mesh_ptr->changedConnectMethod(this, &ProviderImpl<PropertyT, MULTI_FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...>>::WithValue<MeshType>::onMeshChange);
        }
 
        explicit WithValue(const std::initializer_list<HeldType>& values, MeshPointerType mesh_ptr = nullptr, InterpolationMethod default_interpolation = INTERPOLATION_LINEAR)
            : values(values), mesh_ptr(mesh_ptr), default_interpolation(default_interpolation) {
            if (mesh_ptr) mesh_ptr->changedConnectMethod(this, &ProviderImpl<PropertyT, MULTI_FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...>>::WithValue<MeshType>::onMeshChange);
        }
 
        template <typename Iterator>
        explicit WithValue(const Iterator& begin, const Iterator& end, MeshPointerType mesh_ptr = nullptr, InterpolationMethod default_interpolation = INTERPOLATION_LINEAR)
            : values(begin, end), mesh_ptr(mesh_ptr), default_interpolation(default_interpolation) {
            if (mesh_ptr) mesh_ptr->changedConnectMethod(this, &ProviderImpl<PropertyT, MULTI_FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...>>::WithValue<MeshType>::onMeshChange);
        }
 
        explicit WithValue(MeshPointerType mesh_ptr = nullptr, const InterpolationMethod& default_interpolation = INTERPOLATION_LINEAR)
            : mesh_ptr(mesh_ptr), default_interpolation(default_interpolation) {
            if (mesh_ptr) mesh_ptr->changedConnectMethod(this, &ProviderImpl<PropertyT, MULTI_FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...>>::WithValue<MeshType>::onMeshChange);
        }
 
        ~WithValue() {
            if (mesh_ptr) mesh_ptr->changedDisconnectMethod(this, &ProviderImpl<PropertyT, MULTI_FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...> >::WithValue<MeshType>::onMeshChange);
        }
 
        HeldType& operator()(size_t n) {
            ensureHasCorrectValue(n);
            return values[n];
        }
 
        const HeldType& operator()(size_t n) const {
            ensureHasCorrectValue(n);
            return values[n];
        }
 
        ProvidedType operator()(EnumType num, shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, _ExtraParams..., InterpolationMethod method = INTERPOLATION_DEFAULT) const override {
            size_t n(num);
            ensureHasCorrectValue(n);
            if (method == INTERPOLATION_DEFAULT) method = default_interpolation;
            return interpolate(mesh_ptr, values[n], dst_mesh, method);
        }
    };
 
    template <typename MeshTransform>
    struct Transform: public ProviderFor<PropertyT, SpaceT> {
 
        static_assert(std::is_same<SpaceT, typename MeshTransform::SourceGeometry>::value, "Bad transform source mesh type");
 
        typedef typename ProviderImpl<PropertyT, MULTI_FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...> >::ProvidedType ProvidedType;
 
        ReceiverFor<PropertyT, typename MeshTransform::TargetGeometry> receiver;
 
        Transform() {
            receiver.changedConnectMethod(this, &Transform::_receiverChanged);
        }
 
        Transform(ProviderFor<PropertyT, typename MeshTransform::TargetGeometry>* provider) {
            receiver.changedConnectMethod(this, &Transform::_receiverChanged);
            receiver.setProvider(provider);
        }
 
        ~Transform() {
            receiver.changedDisconnectMethod(this, &Transform::_receiverChanged);
        }
 
        size_t size() const override {
            return receiver.size();
        }
 
 
        ProvidedType operator()(EnumType num, shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, _ExtraParams...params, InterpolationMethod method = INTERPOLATION_DEFAULT) const override {
            auto trans_mesh(make_shared<MeshTransform>(dst_mesh));
            return PropertyAt<PropertyT, SpaceT, typename MeshTransform::TargetGeometry>::convertLazyData(receiver(num, trans_mesh, params..., method), trans_mesh);
        }
 
      private:
 
         void _receiverChanged(ReceiverBase&, ReceiverBase::ChangeReason) {
             this->fireChanged();
         }
 
    };
 
    struct Delegate: public PolymorphicDelegateProvider<ProviderFor<PropertyT, SpaceT>, ProvidedType(EnumType n, shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, _ExtraParams..., InterpolationMethod method)> {
 
        typedef PolymorphicDelegateProvider<ProviderFor<PropertyT, SpaceT>, ProvidedType(EnumType n, shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, _ExtraParams..., InterpolationMethod method)> Base;
 
        std::function<size_t()> sizeGetter;
 
        template<typename Functor, typename Sizer>
        Delegate(Functor functor, Sizer sizer): Base(functor), sizeGetter(sizer) {}
 
        template<typename ClassType, typename MemberType, typename Sizer>
        Delegate(ClassType* object, MemberType member, Sizer sizer): Base(object, member), sizeGetter(sizer) {}
 
        template<typename ClassType, typename MemberType>
        Delegate(ClassType* object, MemberType member, size_t (ClassType::*sizer)()const): Base(object, member),
            sizeGetter([object, sizer]() { return (object->*sizer)(); }) {}
 
        template<typename ClassType, typename MemberType>
        Delegate(ClassType* object, MemberType member, size_t (ClassType::*sizer)()): Base(object, member),
            sizeGetter([object, sizer]() { return (object->*sizer)(); }) {}
 
        template<typename Functor>
        Delegate(Functor functor): Base(functor), sizeGetter([]{return PropertyT::NUM_VALS;}) {}
 
        template<typename ClassType, typename MemberType, typename Sizer>
        Delegate(ClassType* object, MemberType member): Base(object, member), sizeGetter([]{return PropertyT::NUM_VALS;}) {}
 
        template<typename ClassType, typename MemberType>
        Delegate(ClassType* object, MemberType member): Base(object, member), sizeGetter([]{return PropertyT::NUM_VALS;}) {}
 
        size_t size() const override {
            return sizeGetter();
        }
 
    };
 
    struct ConstProviderType: public ProviderFor<PropertyT, SpaceT> {
 
        typedef typename ProviderImpl<PropertyT, MULTI_FIELD_PROPERTY, SpaceT, VariadicTemplateTypesHolder<_ExtraParams...>>::ProvidedType ProvidedType;
 
        std::vector<ValueType> values;
 
        // /**
        //  * Constructor which delegates all parameters to the vector constructor.
        //  * @param params ValueT constructor parameters, forwarded to value
        //  */
        // template<typename ...Args>
        // ConstProviderType(Args&&... params): values(std::forward<Args>(params)...) {}
 
        ConstProviderType(const ValueType& value): values({value}) {}
 
        ConstProviderType(ValueType&& value): values({std::move(value)}) {}
 
        ConstProviderType(const std::initializer_list<ValueType>& values): values(values) {}
 
        template <typename Iterator>
        explicit ConstProviderType(const Iterator& begin, const Iterator& end): values(begin, end) {}
 
        ProvidedType operator()(EnumType num, shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, _ExtraParams..., InterpolationMethod) const override {
            if (num >= values.size()) throw BadInput(std::string("Provider for ") + PropertyT::NAME, "value number too large");
            return ProvidedType(dst_mesh->size(), values[num]);
        }
 
        size_t size() const override {
            return values.size();
        }
    };
};
 
}   // namespace plask
 
#endif // PLASK__PROVIDERFOR_H