combined_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__COMBINATE_PROVIDERS_H
#define PLASK__COMBINATE_PROVIDERS_H
 
#include <set>
#include <boost/iterator/indirect_iterator.hpp>
 
#include "providerfor.hpp"
 
namespace plask {
 
template <typename BaseProviderT>
struct CombinedProviderBase: public BaseProviderT {
 
    typedef BaseProviderT BaseType;
 
  private:
 
    std::set<BaseProviderT*> private_providers;
 
    void onChange(Provider& which, bool isDeleted) {
        if (isDeleted) {
            private_providers.erase(static_cast<BaseProviderT*>(&which));
            providers.erase(static_cast<BaseProviderT*>(&which));
        }
        this->fireChanged();
    }
 
  protected:
    std::set<BaseProviderT*> providers;
 
  public:
 
    typedef boost::indirect_iterator<typename std::set<BaseProviderT*>::iterator> iterator;
 
    typedef boost::indirect_iterator<typename std::set<BaseProviderT*>::const_iterator> const_iterator;
 
    iterator begin() { return providers.begin(); }
 
    iterator end() { return providers.end(); }
 
    const_iterator begin() const { return providers.begin(); }
 
    const_iterator end() const { return providers.end(); }
 
    void add(BaseProviderT* to_add, bool providerIsPrivate = false) {
        providers.insert(to_add);
        if (providerIsPrivate) private_providers.insert(to_add);
        to_add->changed.connect(boost::bind(&CombinedProviderBase::onChange, this, _1, _2));
        this->fireChanged();
    }
 
    void add(std::unique_ptr<BaseProviderT>&& to_add) {
        add(to_add->release(), true);
    }
 
    void remove(BaseProviderT* to_remove) {
        to_remove->changed.disconnect(boost::bind(&CombinedProviderBase::onChange, this, _1, _2));
        if (private_providers.erase(to_remove) > 0) delete to_remove;
        providers.erase(to_remove);
    }
 
    void clear() {
        while (!providers.empty()) remove(*providers.begin());
    }
 
    ~CombinedProviderBase() {
        clear();
    }
 
    bool empty() const { return providers.empty(); }
 
    std::size_t size() const { return providers.size(); }
 
    void ensureHasProviders() const {
        if (providers.empty())
            throw Exception("combined {0} provider has no components", this->name());
    }
 
};
 
 
template <typename, typename, typename> struct FieldSumProviderImpl;
 
template <typename PropertyT, typename SpaceT, typename... ExtraArgs>
struct FieldSumProviderImpl<PropertyT, SpaceT, VariadicTemplateTypesHolder<ExtraArgs...>>: public CombinedProviderBase<ProviderFor<PropertyT, SpaceT>> {
 
    typedef typename ProviderFor<PropertyT, SpaceT>::ProvidedType ProvidedType;
    typedef typename ProviderFor<PropertyT, SpaceT>::ValueType ValueType;
 
    struct SumLazyDataImpl: public LazyDataImpl<ValueType> {
 
        std::vector<LazyData<ValueType>> to_sum;
 
        std::size_t _size;
 
        SumLazyDataImpl(std::vector<LazyData<ValueType>>&& to_sum, std::size_t size)
            : to_sum(std::move(to_sum)), _size(size) {}
 
        ValueType at(std::size_t index) const override {
            ValueType sum = to_sum[0][index];
            for (std::size_t i = 1; i < to_sum.size(); ++i)
                sum += to_sum[i][index];
            return sum;
        }
 
        std::size_t size() const override {
            return _size;
        }
 
    };
 
    ProvidedType operator()(shared_ptr<const MeshD<SpaceT::DIM>> dst_mesh, ExtraArgs... extra_args, InterpolationMethod method=INTERPOLATION_DEFAULT) const override {
        this->ensureHasProviders();
        std::vector<LazyData<ValueType>> providers;
        auto p = this->begin();
        providers.push_back((*p)(dst_mesh, std::forward<ExtraArgs>(extra_args)..., method));
        ++p;
        if (p == this->end()) return std::move(providers.front());    // has one element
        std::size_t size = providers.front().size();
        do {
            std::size_t last_size = providers.back().size();
            if (size != last_size)
                throw DataError("data sources sizes differ ([{0}] - [%2])", size, last_size);
            providers.push_back((*p)(dst_mesh, std::forward<ExtraArgs>(extra_args)..., method));
            ++p;
        } while (p != this->end());
        return new SumLazyDataImpl(std::move(providers), size);
    }
};
 
template <typename PropertyT, typename SpaceT>
struct FieldSumProvider: public FieldSumProviderImpl<PropertyT, SpaceT, typename PropertyT::ExtraParams> {};
 
 
}   // namespace plask
 
#endif // COMBINATE_PROVIDERS_H