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_H
#define PLASK__GEOMETRY_CONTAINER_H
 
#include <algorithm>
#include <cmath>  //fmod
#include <vector>
#include "../utils/metaprog.hpp"
 
#include "../manager.hpp"
#include "../utils/string.hpp"
#include "align.hpp"
#include "path.hpp"
#include "reader.hpp"
 
namespace plask {
 
template <int dim> struct PLASK_API GeometryObjectContainer : public GeometryObjectD<dim> {
    typedef typename GeometryObjectContainer<dim>::DVec DVec;
 
    typedef typename GeometryObjectContainer<dim>::Box Box;
 
    typedef GeometryObjectD<dim> ChildType;
 
    typedef Translation<dim> TranslationT;
 
    typedef std::vector<shared_ptr<TranslationT>> TranslationVector;
 
  protected:
    TranslationVector children;
 
    virtual void writeXMLChildAttr(XMLWriter::Element& dest_xml_child_tag,
                                   std::size_t child_index,
                                   const AxisNames& axes) const;
 
    virtual shared_ptr<GeometryObject> changedVersionForChildren(
        std::vector<std::pair<shared_ptr<ChildType>, Vec<3, double>>>& children_after_change,
        Vec<3, double>* recomended_translation) const = 0;
 
  public:
    virtual void writeXML(XMLWriter::Element& parent_xml_object,
                          GeometryObject::WriteXMLCallback& write_cb,
                          AxisNames axes) const override;
 
    // TODO container should reduce number of generated event from child if have 2 or more same children, for each
    // children should be connected once
 
    ~GeometryObjectContainer() {
        for (auto& c : children) disconnectOnChildChanged(*c);
    }
 
    virtual void onChildChanged(const GeometryObject::Event& evt);
 
    void connectOnChildChanged(Translation<dim>& child);
 
    void disconnectOnChildChanged(Translation<dim>& child);
 
    const TranslationVector& getChildrenVector() const { return children; }
 
    GeometryObject::Type getType() const override { return GeometryObject::TYPE_CONTAINER; }
 
    bool contains(const DVec& p) const override;
 
    // TODO to use (impl. is good) or remove
    /*virtual bool intersects(const Box& area) const {
        for (auto child: children) if (child->intersects(area)) return true;
        return false;
    }*/
 
    Box getBoundingBox() const override;
 
    shared_ptr<Material> getMaterial(const DVec& p) const override;
 
    /*virtual void getLeafsInfoToVec(std::vector< std::tuple<shared_ptr<const GeometryObject>, Box, DVec> >& dest, const
    PathHints* path = 0) const { if (path) { auto c = path->getTranslationChildren<dim>(*this); if (!c.empty()) { for
    (auto child: c) child->getLeafsInfoToVec(dest, path); return;
            }
        }
        for (auto child: children) child->getLeafsInfoToVec(dest, path);
    }*/
 
    void getBoundingBoxesToVec(const GeometryObject::Predicate& predicate,
                               std::vector<Box>& dest,
                               const PathHints* path = 0) const override;
 
    void getObjectsToVec(const GeometryObject::Predicate& predicate,
                         std::vector<shared_ptr<const GeometryObject>>& dest,
                         const PathHints* path = 0) const override;
 
    /*virtual void getLeafsToVec(std::vector< shared_ptr<const GeometryObject> >& dest) const {
        for (auto child: children) child->getLeafsToVec(dest);
    }*/
 
    virtual void getPositionsToVec(const GeometryObject::Predicate& predicate,
                                   std::vector<DVec>& dest,
                                   const PathHints* path = 0) const override;
 
    // void extractToVec(const GeometryObject::Predicate &predicate, std::vector< shared_ptr<const GeometryObjectD<dim>
    // > >& dest, const PathHints *path) const;
 
    /*virtual std::vector< std::tuple<shared_ptr<const GeometryObject>, DVec> > getLeafsWithTranslations() const {
        std::vector< std::tuple<shared_ptr<const GeometryObject>, DVec> > result;
        for (auto child: children) {
            std::vector< std::tuple<shared_ptr<const GeometryObject>, DVec> > child_leafs_tran =
    child->getLeafsWithTranslations(); result.insert(result.end(), child_leafs_tran.begin(), child_leafs_tran.end());
        }
        return result;
    }*/
 
    bool hasInSubtree(const GeometryObject& el) const override;
 
    template <typename ChildIter>
    GeometryObject::Subtree findPathsFromChildTo(ChildIter childBegin,
                                                 ChildIter childEnd,
                                                 const GeometryObject& el,
                                                 const PathHints* path = 0) const {
        GeometryObject::Subtree result;
        for (auto child_iter = childBegin; child_iter != childEnd; ++child_iter) {
            GeometryObject::Subtree child_path = (*child_iter)->getPathsTo(el, path);
            if (!child_path.empty()) result.children.push_back(std::move(child_path));
        }
        if (!result.children.empty()) result.object = this->shared_from_this();
        return result;
    }
 
    GeometryObject::Subtree getPathsTo(const GeometryObject& el, const PathHints* path = 0) const override;
 
    GeometryObject::Subtree getPathsAt(const DVec& point, bool all = false) const override;
 
    std::size_t getChildrenCount() const override;
 
    shared_ptr<GeometryObject> getChildNo(std::size_t child_no) const override;
 
    std::size_t getChildIndex(const shared_ptr<ChildType>& el, const PathHints* path = 0) const;
 
    std::size_t getChildIndex(const shared_ptr<ChildType>& el, const PathHints& path) const {
        return getChildIndex(el, &path);
    }
 
    /*virtual shared_ptr<TranslationT> getTranslationOfRealChildAt(std::size_t child_no) const {
        this->ensureIsValidChildNr(child_no);
        return children[child_no];
    }*/
 
    virtual shared_ptr<const GeometryObject> changedVersion(const GeometryObject::Changer& changer,
                                                            Vec<3, double>* translation = 0) const override;
 
    virtual bool removeIfTUnsafe(const std::function<bool(const shared_ptr<TranslationT>& c)>& predicate);
 
    bool removeIfT(const std::function<bool(const shared_ptr<TranslationT>& c)>& predicate);
 
    bool removeIf(const std::function<bool(const shared_ptr<ChildType>& c)>& predicate) {
        return removeIfT(
            [&](const shared_ptr<const TranslationT>& c) { return c->getChild() && predicate(c->getChild()); });
    }
 
    bool removeT(shared_ptr<const TranslationT> el) {
        return removeIfT([&el](const shared_ptr<const TranslationT>& c) { return c == el; });
    }
 
    bool remove(shared_ptr<const ChildType> el) {
        return removeIf([&el](const shared_ptr<const ChildType>& c) { return c == el; });
    }
 
    bool remove(const PathHints& hints) {
        auto cset = hints.getChildren(*this);
        return removeIfT([&](const shared_ptr<TranslationT>& t) {
            return cset.find(static_pointer_cast<GeometryObject>(t)) != cset.end();
        });
    }
 
    void removeAtUnsafe(std::size_t index) override;
 
    void clear() {
        removeIfT([](const shared_ptr<ChildType>&) { return true; });
    }
 
    template <typename UnaryFunction> void forEachChild(UnaryFunction fun, const PathHints* path = nullptr) const {
        if (path) {
            auto c = path->getTranslationChildren<dim>(*this);
            if (!c.empty()) {
                for (auto child : c) fun(*child);
                return;
            }
        }
        for (auto child : children) fun(*child);
    }
 
    void addPointsAlongToSet(std::set<double>& points,
                             Primitive<3>::Direction direction,
                             unsigned max_steps,
                             double min_step_size) const override;
 
    void addLineSegmentsToSet(std::set<typename GeometryObjectD<dim>::LineSegment>& segments,
                              unsigned max_steps,
                              double min_step_size) const override;
};
 
PLASK_API_EXTERN_TEMPLATE_STRUCT(GeometryObjectContainer<2>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(GeometryObjectContainer<3>)
 
 
template <typename ChildParamF, typename WithoutChildParamF>
inline void read_children(GeometryReader& reader,
                          ChildParamF child_param_read,
                          WithoutChildParamF without_child_param_read) {
    while (reader.source.requireTagOrEnd()) {
        if (reader.source.getNodeName() == "item") {
            plask::optional<std::string> paths_str = reader.source.getAttribute("path");
            PathHints::Hint hint = child_param_read();  // this calls readExactlyOneChild
            if (paths_str) {
                auto paths = splitEscIterator(*paths_str, ',');
                for (std::string path : paths) {
                    std::replace(path.begin(), path.end(), '-', '_');
                    BadId::throwIfBad("path", path);
                    reader.manager.pathHints[path].addHint(hint);
                }
            }
        } else {
            without_child_param_read();
        }
    }
}
 
template <typename ParentType, typename ChildAlignerType> struct WithAligners : public ParentType {
    typedef ChildAlignerType ChildAligner;
    typedef typename ParentType::TranslationT TranslationT;
 
  protected:
    using ParentType::children;
 
    std::vector<ChildAligner> aligners;
 
    PathHints::Hint _insertUnsafe(const std::size_t pos, shared_ptr<TranslationT> to_insert, ChildAligner aligner) {
        this->ensureIsValidInsertPosition(pos, "insertUnsafe");
        this->children.insert(children.begin() + pos, to_insert);
        aligners.insert(aligners.begin() + pos, aligner);
        this->connectOnChildChanged(*to_insert);
        this->fireChildrenInserted(pos, pos + 1);
        return PathHints::Hint(this->shared_from_this(), to_insert);
    }
 
    PathHints::Hint _insert(const std::size_t pos, shared_ptr<TranslationT> to_insert, ChildAligner aligner) {
        if (to_insert) this->ensureCanHaveAsChild(*to_insert);
        return _insertUnsafe(pos, to_insert, aligner);
    }
 
    PathHints::Hint _addUnsafe(shared_ptr<TranslationT> to_add, ChildAligner aligner) {
        this->children.push_back(to_add);
        aligners.push_back(aligner);
        this->connectOnChildChanged(*to_add);
        this->fireChildrenInserted(children.size() - 1, children.size());
        return PathHints::Hint(this->shared_from_this(), to_add);
    }
 
    /*PathHints::Hint _add(shared_ptr<TranslationT> to_add, ChildAligner aligner) {
        if (to_add) this->ensureCanHaveAsChild(*to_add);
        this->_addUnsafe(to_add, aligner);
        return PathHints::Hint(this->shared_from_this(), to_add);
    }*/
 
    ChildAligner getAlignerFor(shared_ptr<const TranslationT> child) {
        auto it = std::find(children.begin(), children.end(), child);
        return it != children.end() ? aligners[it - children.begin()] : ChildAligner();
    }
 
    ChildAligner getAlignerFor(TranslationT& child) {
        auto it = std::find(children.begin(), children.end(),
                            static_pointer_cast<const TranslationT>(child.shared_from_this()));
        return it != children.end() ? aligners[it - children.begin()] : ChildAligner();
    }
 
    void align(shared_ptr<TranslationT> child) {
        auto it = std::find(children.begin(), children.end(), child);
        if (it != children.end()) aligners[it - children.begin()].align(*child);
    }
 
    void align(TranslationT* child) { align(static_pointer_cast<TranslationT>(child->shared_from_this())); }
 
    void align(TranslationT& child) { align(static_pointer_cast<TranslationT>(child.shared_from_this())); }
 
  public:
    // using ParentType::ParentType;//this is fine but not implemented in GCC 4.7
    template <typename... Args> WithAligners(Args&&... args) : ParentType(std::forward<Args>(args)...) {}
 
    void onChildChanged(const GeometryObject::Event& evt) override {
        if (evt.isResize()) align(const_cast<TranslationT*>(evt.source<TranslationT>()));
        ParentType::onChildChanged(evt);
    }
 
    bool removeIfTUnsafe(const std::function<bool(const shared_ptr<TranslationT>& c)>& predicate) override {
        auto dst = this->children.begin();
        auto al_dst = aligners.begin();
        auto al_src = aligners.begin();
        for (auto i : children) {
            if (predicate(i)) this->disconnectOnChildChanged(*i);
            else {
                *dst++ = i;
                *al_dst++ = std::move(*al_src);
            }
            ++al_src;
        }
        if (dst != children.end()) {
            children.erase(dst, children.end());
            aligners.erase(al_dst, aligners.end());
            return true;
        } else
            return false;
    }
 
    void removeAtUnsafe(std::size_t index) override {
        ParentType::removeAtUnsafe(index);
        aligners.erase(aligners.begin() + index);
    }
 
    void writeXMLChildAttr(XMLWriter::Element& dest_xml_child_tag,
                           std::size_t child_index,
                           const AxisNames& axes) const override {
        aligners[child_index].writeToXML(dest_xml_child_tag, axes);
    }
 
    void move(std::size_t index, ChildAligner aligner) {
        this->ensureIsValidChildNr(index, "move", "index");
        aligners[index] = aligner;
        aligners[index].align(*children[index]);
        this->fireChildrenChanged();  // or children[child_no]->fireChanged();??
    }
 
    void move(shared_ptr<const TranslationT> child, ChildAligner aligner) {
        auto it = std::find(children.begin(), children.end(), child);
        if (it != children.end()) move(it - children.begin(), aligner);
    }
 
    void move(const TranslationT& child, ChildAligner aligner) {
        move(static_pointer_cast<const TranslationT>(child.shared_from_this()), aligner);
    }
 
    const std::vector<ChildAligner>& getAligners() const {
        return aligners;
    }
};
 
}  // namespace plask
 
#endif  // PLASK__GEOMETRY_CONTAINER_H