translation_container.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__GEOMETRY_CONTAINER_TRANS_H
#define PLASK__GEOMETRY_CONTAINER_TRANS_H
 
#include "container.hpp"
#include "spatial_index.hpp"
 
#include <boost/thread.hpp>
#include <atomic>
 
namespace plask {
 
template < int dim >
struct PLASK_API TranslationContainer: public WithAligners<GeometryObjectContainer<dim>, align::AlignerD<dim>> {
 
    friend struct Lattice;
 
    typedef typename GeometryObjectContainer<dim>::DVec DVec;
 
    typedef typename GeometryObjectContainer<dim>::Box Box;
 
    typedef typename GeometryObjectContainer<dim>::ChildType ChildType;
 
    typedef align::AlignerD<dim> ChildAligner;
 
    typedef typename GeometryObjectContainer<dim>::TranslationT TranslationT;
 
    using GeometryObjectContainer<dim>::children;
    using GeometryObjectContainer<dim>::shared_from_this;
 
    static const char* NAME;
 
    TranslationContainer(): cache(nullptr) {}
 
    TranslationContainer(const TranslationContainer& to_copy)
        : WithAligners<GeometryObjectContainer<dim>, align::AlignerD<dim>>(to_copy) {}
 
    ~TranslationContainer();
 
    std::string getTypeName() const override { return NAME; }
 
    PathHints::Hint addUnsafe(shared_ptr<ChildType> el, ChildAligner aligner);
 
    PathHints::Hint addUnsafe(shared_ptr<ChildType> el, const DVec& translation = Primitive<dim>::ZERO_VEC);
 
    PathHints::Hint add(shared_ptr<ChildType> el, ChildAligner aligner) {
        if (el) this->ensureCanHaveAsChild(*el);
        return addUnsafe(el, aligner);
    }
 
    PathHints::Hint add(shared_ptr<ChildType> el, const DVec& translation = Primitive<dim>::ZERO_VEC) {
        if (el) this->ensureCanHaveAsChild(*el);
        return addUnsafe(el, translation);
    }
 
    PathHints::Hint insertUnsafe(const std::size_t pos, shared_ptr<ChildType> el, ChildAligner aligner);
 
    PathHints::Hint insertUnsafe(const std::size_t pos, shared_ptr<ChildType> el, const DVec& translation = Primitive<dim>::ZERO_VEC);
 
    PathHints::Hint insert(const std::size_t pos, shared_ptr<ChildType> el, ChildAligner aligner) {
        if (el) this->ensureCanHaveAsChild(*el);
        return insertUnsafe(pos, el, aligner);
    }
 
    PathHints::Hint insert(const std::size_t pos, shared_ptr<ChildType> el, const DVec& translation = Primitive<dim>::ZERO_VEC) {
        if (el) this->ensureCanHaveAsChild(*el);
        return insertUnsafe(pos, el, translation);
    }
 
    //methods overwrite to use cache:
    shared_ptr<Material> getMaterial(const DVec& p) const override {
        return ensureHasCache()->getMaterial(p);
    }
 
    bool contains(const DVec& p) const override {
        return ensureHasCache()->contains(p);
    }
 
    GeometryObject::Subtree getPathsAt(const DVec& point, bool all=false) const override {
        return ensureHasCache()->getPathsAt(this->shared_from_this(), point, all);
    }
 
    //some methods must be overwrite to invalidate cache:
    void onChildChanged(const GeometryObject::Event& evt) override {
        if (evt.isResize()) invalidateCache();
        WithAligners<GeometryObjectContainer<dim>, align::AlignerD<dim>>::onChildChanged(evt);
    }
 
    bool removeIfTUnsafe(const std::function<bool(const shared_ptr<TranslationT>& c)>& predicate) override {
        if (WithAligners<GeometryObjectContainer<dim>, align::AlignerD<dim>>::removeIfTUnsafe(predicate)) {
            invalidateCache();
            return true;
        } else
            return false;
    }
 
    void removeAtUnsafe(std::size_t index) override {
        invalidateCache();
        WithAligners<GeometryObjectContainer<dim>, align::AlignerD<dim>>::removeAtUnsafe(index);
    }
 
    //virtual void writeXMLChildAttr(XMLWriter::Element &dest_xml_child_tag, std::size_t child_index, const AxisNames &axes) const;
 
    shared_ptr<GeometryObject> shallowCopy() const override;
 
    shared_ptr<GeometryObject> deepCopy(std::map<const GeometryObject*, shared_ptr<GeometryObject>>& copied) const override;
 
protected:
    shared_ptr<GeometryObject> changedVersionForChildren(std::vector<std::pair<shared_ptr<ChildType>, Vec<3, double>>>& children_after_change, Vec<3, double>* recomended_translation) const override;
 
    void invalidateCache();
 
    SpatialIndexNode<dim>* ensureHasCache();
 
    SpatialIndexNode<dim>* ensureHasCache() const;
 
private:
    shared_ptr<TranslationT> newTranslation(const shared_ptr<ChildType>& el, ChildAligner aligner);
 
    std::atomic<SpatialIndexNode<dim>*> cache;
 
    boost::mutex cache_mutex;
 
};
 
PLASK_API_EXTERN_TEMPLATE_STRUCT(TranslationContainer<2>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(TranslationContainer<3>)
 
} // namespace plask
 
#endif // PLASK__GEOMETRY_CONTAINER_TRANS_H