provider.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__PROVIDER_H
#define PLASK__PROVIDER_H
 
#include <set>
#include <vector>
#include <functional>   // std::function
#include <type_traits>  // std::is_same
#include "../optional.hpp"
#include <boost/signals2.hpp>
 
 
#include "../exceptions.hpp"
#include "../utils/stl.hpp"
#include "../mesh/mesh.hpp"
#include "../mesh/interpolation.hpp"
 
namespace plask {
 
struct PLASK_API Provider {
 
    static constexpr const char* NAME = "undefined";
    virtual const char* name() const { return NAME; }
 
    Provider & operator=(const Provider&) = delete;
    Provider(const Provider&) = delete;
    Provider() = default;
 
    boost::signals2::signal<void(Provider&, bool)> changed;
 
    virtual ~Provider() {
        changed(*this, true);
    }
 
    void fireChanged() {
        changed(*this, false);
    }
 
};
 
struct PLASK_API ReceiverBase {
 
    enum class ChangeReason {
        REASON_DELETE,     
        REASON_VALUE,      
        REASON_PROVIDER    
    };
 
    virtual ~ReceiverBase() {}
};
 
template <typename ProviderT>
class Receiver: public ReceiverBase {
 
    boost::signals2::connection providerConnection;
 
protected:
 
    bool _hasPrivateProvider;
 
public:
 
    typedef Receiver<ProviderT> Base;
 
    static constexpr const char* PROVIDER_NAME = ProviderT::NAME;
    virtual const char* providerName() const { return PROVIDER_NAME; }
 
    boost::signals2::signal<void(ReceiverBase& src, ChangeReason reason)> providerValueChanged;
 
    Receiver& operator=(const Receiver&) = delete;
    Receiver(const Receiver&) = delete;
 
    typedef ProviderT ProviderType;
 
    ProviderT* provider;
 
    Receiver(): _hasPrivateProvider(false), provider(0) {}
 
    virtual ~Receiver() {
        providerConnection.disconnect();
        if (_hasPrivateProvider) {
            delete this->provider;
            this->provider = nullptr;
        }
        fireChanged(ChangeReason::REASON_DELETE);
    }
 
    void fireChanged(ChangeReason reason) {
        providerValueChanged(*this, reason);
    }
 
    void setProvider(ProviderT* provider, bool newProviderIsPrivate = false) {
        if (this->provider == provider) {
            this->_hasPrivateProvider = newProviderIsPrivate;
            return;
        }
        providerConnection.disconnect();
        if (_hasPrivateProvider) delete this->provider;
        if (provider) providerConnection = provider->changed.connect(
                    [&](Provider& PLASK_UNUSED(which), bool isDeleted) {
                        if (isDeleted) {
                            providerConnection.disconnect();    //TODO do we need this line?
                            this->provider = 0;
                        }
                        this->fireChanged(isDeleted ? ChangeReason::REASON_PROVIDER : ChangeReason::REASON_VALUE);
                    });
        this->provider = provider;
        this->_hasPrivateProvider = newProviderIsPrivate;
        this->fireChanged(ChangeReason::REASON_PROVIDER);
    }
 
    void setProvider(ProviderT &provider) {
        setProvider(&provider);
    }
 
    void setProvider(std::unique_ptr<ProviderT>&& provider) {
        setProvider(provider->release(), true);
    }
 
    /*
     * Change provider. If new provider is different from current one then changed flag is set.
     * @param provider new provider, can be @c nullptr to only disconnect from current provider.
     */
    /*void operator=(ProviderT *provider) {
        setProvider(provider);
    }*/
 
    /*
     * Change provider. If new provider is different from current one then changed flag is set.
     * @param provider new provider
     */
    /*void operator=(ProviderT &provider) {
        setProvider(&provider);
    }*/
 
    ProviderT* getProvider() { return provider; }
 
    const ProviderT* getProvider() const { return provider; }
 
    bool hasProvider() const {
        return provider;
    }
 
    void ensureHasProvider() const {
        if (provider == nullptr)
            throw NoProvider(providerName());
    }
 
    template<typename ...Args> auto
    operator()(const Args&... params) const -> decltype((*provider)(params...)) {
        beforeGetValue();
        return (*provider)(params...);
    }
 
    template<typename ...Args> auto
    optional(const Args&... params) const -> plask::optional<decltype((*provider)(params...))> {
        try {
            return plask::optional<decltype((*provider)(params...))>(this->operator()(params...));
        } catch (std::exception&) {
            return plask::optional<decltype((*provider)(params...))>();
        }
    }
 
    template <typename ...ConstProviderConstructorArgs>
    void setConstValue(ConstProviderConstructorArgs&&... constProviderConstructorArgs) {
        setProvider(new typename ProviderT::ConstProviderType(std::forward<ConstProviderConstructorArgs>(constProviderConstructorArgs)...), true);
    }
 
    template <typename ClassT, typename methodT>
    boost::signals2::connection changedConnectMethod(ClassT* obj, methodT method, boost::signals2::connect_position at=boost::signals2::at_back) {
        return providerValueChanged.connect(boost::bind(method, obj, _1, _2), at);
    }
 
    template <typename ClassT, typename methodT>
    void changedDisconnectMethod(ClassT* obj, methodT method) {
        providerValueChanged.disconnect(boost::bind(method, obj, _1, _2));
    }
 
protected:
 
    void beforeGetValue() const {
        ensureHasProvider();
    }
 
};
 
template <typename ValueT, typename... ArgsT>
struct SingleValueProvider: public Provider {
 
    static constexpr const char* NAME = "undefined value";
    const char* name() const override { return NAME; }
 
    typedef ValueT ProvidedType;
 
    virtual ProvidedType operator()(ArgsT...) const = 0;
 
};
 
template <typename ValueT, typename EnumT, typename... ArgsT>
struct MultiValueProvider: public Provider {
 
    static constexpr const char* NAME = "undefined value";
    const char* name() const override { return NAME; }
 
    typedef ValueT ProvidedType;
 
    typedef EnumT EnumType;
 
    virtual ProvidedType operator()(EnumT num, ArgsT...) const = 0;
 
    virtual size_t size() const = 0;
 
};
 
//TODO typedef for SingleValueReceiver (GCC 4.7 needed)
 
template <typename ValueT, typename SpaceT, typename... ExtraArgs>
struct FieldProvider: public Provider {
 
    static constexpr const char* NAME = "undefined field";
    const char* name() const override { return NAME; }
 
    typedef LazyData<ValueT> ProvidedType;
    typedef SpaceT SpaceType;
 
    virtual ProvidedType operator()(shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, ExtraArgs... extra_args, InterpolationMethod method) const = 0;
 
    inline ProvidedType operator()(shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, ExtraArgs... extra_args) const {
        return this->operator()(dst_mesh, extra_args..., INTERPOLATION_DEFAULT);
    }
 
    inline ProvidedType operator()(shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, std::tuple<ExtraArgs...> extra_args, InterpolationMethod method = INTERPOLATION_DEFAULT) const {
        typedef std::tuple<ExtraArgs...> Tuple;
        return apply_tuple(dst_mesh, method, std::forward<Tuple>(extra_args), make_seq_indices<0, sizeof...(ExtraArgs)>{});
    }
 
private:
    template <typename T,  template <std::size_t...> class I, std::size_t... Indices>
    inline ProvidedType apply_tuple(shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, InterpolationMethod method, T&& t, I<Indices...>) const {
      return this->operator()(dst_mesh, std::get<Indices>(std::forward<T>(t))..., method);
    }
 
};
 
template <typename ValueT, typename SpaceT, typename EnumT, typename... ExtraArgs>
struct MultiFieldProvider: public Provider {
 
    static constexpr const char* NAME = "undefined field";
    const char* name() const override { return NAME; }
 
    typedef LazyData<ValueT> ProvidedType;
 
    typedef EnumT EnumType;
 
    virtual size_t size() const = 0;
 
    virtual ProvidedType operator()(EnumT num, shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, ExtraArgs... extra_args, InterpolationMethod method) const = 0;
 
    inline ProvidedType operator()(EnumT num, shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, ExtraArgs... extra_args) const {
        return this->operator()(num, dst_mesh, extra_args..., INTERPOLATION_DEFAULT);
    }
 
    inline ProvidedType operator()(EnumT num, shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, std::tuple<ExtraArgs...>&& extra_args, InterpolationMethod method = INTERPOLATION_DEFAULT) const {
        typedef std::tuple<ExtraArgs...> Tuple;
        return apply_tuple(num, dst_mesh, method, std::forward<Tuple>(extra_args), make_seq_indices<0, sizeof...(ExtraArgs)>{});
    }
 
    inline ProvidedType operator()(shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, ExtraArgs... extra_args, InterpolationMethod method) const {
        return this->operator()(EnumT(0), dst_mesh, extra_args..., method);
    }
 
    inline ProvidedType operator()(shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, ExtraArgs... extra_args) const {
        return this->operator()(EnumT(0), dst_mesh, extra_args..., INTERPOLATION_DEFAULT);
    }
 
    inline ProvidedType operator()(shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, std::tuple<ExtraArgs...>&& extra_args, InterpolationMethod method = INTERPOLATION_DEFAULT) const {
        typedef std::tuple<ExtraArgs...> Tuple;
        return apply_tuple(EnumT(0), dst_mesh, method, std::forward<Tuple>(extra_args), make_seq_indices<0, sizeof...(ExtraArgs)>{});
    }
 
private:
    template <typename T,  template <std::size_t...> class I, std::size_t... Indices>
    inline ProvidedType apply_tuple(size_t num, shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, InterpolationMethod method, T&& t, I<Indices...>) {
      return this->operator()(num, dst_mesh, std::get<Indices>(std::forward<T>(t))..., method);
    }
 
};
 
 
template<typename _Signature> struct DelegateProvider;
 
template<typename _Res, typename... _ArgTypes>
struct DelegateProvider<_Res(_ArgTypes...)>: public Provider {
 
    std::function<_Res(_ArgTypes...)> valueGetter;
 
    template<typename ...Args>
    DelegateProvider<_Res(_ArgTypes...)>(Args&&... params)
    : valueGetter(std::forward<Args>(params)...) {
    }
 
    virtual _Res operator()(_ArgTypes&&... params) const {
        return valueGetter(std::forward<_ArgTypes>(params)...);
    }
};
 
template<typename _BaseClass, typename _Signature> struct PolymorphicDelegateProvider;
 
template<typename _BaseClass, typename _Res, typename... _ArgTypes>
struct PolymorphicDelegateProvider<_BaseClass, _Res(_ArgTypes...)>: public _BaseClass {
 
 
    std::function<_Res(_ArgTypes...)> valueGetter;
 
    PolymorphicDelegateProvider() = delete;
 
    template<typename Functor>
    PolymorphicDelegateProvider<_BaseClass, _Res(_ArgTypes...)>(Functor functor)
        : valueGetter(functor)
    {}
 
    template<typename ClassType, typename MemberType>
    PolymorphicDelegateProvider<_BaseClass, _Res(_ArgTypes...)>(ClassType* object, MemberType member)
        : valueGetter(
          [object, member](_ArgTypes&&... params) {
              return (object->*member)(std::forward<_ArgTypes>(params)...);
          })
    {}
 
    template<typename ...Args>
    PolymorphicDelegateProvider<_BaseClass, _Res(_ArgTypes...)>(Args&&... params)
    : valueGetter(std::forward<Args>(params)...) {
    }
 
    _Res operator()(_ArgTypes... params) const override {
        return valueGetter(std::forward<_ArgTypes>(params)...);
    }
};
 
}; //namespace plask
 
#endif  //PLASK__PROVIDER_H