path.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_PATH_H
#define PLASK__GEOMETRY_PATH_H
 
#include <map>
#include <set>
#include <plask/config.hpp>
#include "transform.hpp"
 
namespace plask {
 
struct GeometryObject;
 
//TODO redefine to structure which allow to cast to container and translation
typedef std::pair< shared_ptr<GeometryObject>, shared_ptr<GeometryObject> > Edge;
 
struct Path;
 
struct PLASK_API PathHints {
 
#ifdef PLASK_SHARED_PTR_STD
    typedef std::map<weak_ptr<GeometryObject>, std::set<weak_ptr<GeometryObject>, std::owner_less<weak_ptr<GeometryObject>>>,
                     std::owner_less<weak_ptr<GeometryObject>>> HintMap;
#else
    typedef std::map<weak_ptr<GeometryObject>, std::set<weak_ptr<GeometryObject>>> HintMap;
#endif
 
    typedef Edge Hint;
 
    HintMap hintFor;
 
    explicit PathHints(const Hint& hint) {
        addHint(hint);
    }
 
    explicit PathHints(const Path& path) {
        addAllHintsFromPath(path);
    }
 
    explicit PathHints(const std::vector< shared_ptr<const GeometryObject> >& path) {
        addAllHintsFromPath(path);
    }
 
    explicit PathHints(const GeometryObject::Subtree& subtree) {
        addAllHintsFromSubtree(subtree);
    }
 
    PathHints() = default;
 
    void addHint(const Hint& hint);
 
    bool includes(shared_ptr<const GeometryObject> container, shared_ptr<const GeometryObject> child_tran) const;
 
    bool includes(const Hint& hint) const {
        return includes(hint.first, hint.second);
    }
 
    PathHints& operator+=(const Hint& hint) {
        addHint(hint);
        return *this;
    }
 
    inline bool operator==(const PathHints& comp) const {
        return !(hintFor < comp.hintFor || comp.hintFor < hintFor);
    }
 
    inline bool operator<(const PathHints& comp) const {
        return hintFor < comp.hintFor;
    }
 
    void addHint(weak_ptr<GeometryObject> container, weak_ptr<GeometryObject> child);
 
    void addAllHintsFromPath(const std::vector< shared_ptr<const GeometryObject> >& pathObjects);
 
    void addAllHintsFromPath(const Path& path);
 
    void addAllHintsFromSubtree(const GeometryObject::Subtree& subtree);
 
    std::set<shared_ptr<GeometryObject>> getChildren(shared_ptr<const GeometryObject> container);
 
    std::set<shared_ptr<GeometryObject>> getChildren(const GeometryObject& container) {
        return getChildren(container.shared_from_this());
    }
 
    std::set<shared_ptr<GeometryObject>> getChildren(shared_ptr<const GeometryObject> container) const;
 
    std::set<shared_ptr<GeometryObject>> getChildren(const GeometryObject& container) const {
        return getChildren(container.shared_from_this());
    }
 
    template <int dim> static
    std::set<shared_ptr<Translation<dim>>> castToTranslation(std::set<shared_ptr<GeometryObject>> src) {
        std::set<shared_ptr<Translation<dim>>> result;
        for (auto& e: src) result.insert(dynamic_pointer_cast<Translation<dim>>(e));
        return result;
    }
 
    template <int dim> std::set<shared_ptr<Translation<dim>>> getTranslationChildren(shared_ptr<const GeometryObject> container) {
        return castToTranslation<dim>(getChildren(container));
    }
 
    template <int dim> std::set<shared_ptr<Translation<dim>>> getTranslationChildren(const GeometryObject& container) {
        return getTranslationChildren<dim>(container.shared_from_this());
    }
 
    template <int dim> std::set<shared_ptr<Translation<dim>>> getTranslationChildren(shared_ptr<const GeometryObject> container) const {
        return castToTranslation<dim>(getChildren(container));
    }
 
    template <int dim> std::set<shared_ptr<Translation<dim>>> getTranslationChildren(const GeometryObject& container) const {
        return getTranslationChildren<dim>(container.shared_from_this());
    }
 
    void cleanDeleted();
 
};
 
struct PLASK_API Path {
 
  private:
 
    bool completeToFirst(const GeometryObject& newFirst, const PathHints* hints = nullptr);
 
    bool completeFromLast(const GeometryObject& newLast, const PathHints* hints = nullptr);
 
  public:
 
    Path(const std::vector< shared_ptr<const GeometryObject> >& path)
        : objects(path) {}
 
    Path(std::vector< shared_ptr<const GeometryObject> >&& path)
        : objects(std::move(path)) {}
 
    Path(const GeometryObject::Subtree& paths)
        : objects(paths.toLinearPath().objects) {}
 
    Path(GeometryObject::Subtree&& paths)
        : objects(paths.toLinearPath().objects) {}
 
    // These are the same as default constructors, so can be skipped:
    // Path(const Path& path): objects(path.objects) {}
    // Path(Path&& path): objects(path.objects) {}
 
    Path(const PathHints::Hint& hint) { append(hint); }
 
    Path(const GeometryObject& object) { append(object); }
 
    Path(shared_ptr<const GeometryObject> object) { append(*object); }
 
    std::vector< shared_ptr<const GeometryObject> > objects;
 
    void push_front(const std::vector< shared_ptr<const GeometryObject> >& toAdd);
 
    void push_back(const std::vector< shared_ptr<const GeometryObject> >& toAdd);
 
    Path& append(const std::vector< shared_ptr<const GeometryObject> >& path, const PathHints* hints = nullptr);
 
    Path& append(const GeometryObject::Subtree& path, const PathHints* hints = nullptr);
 
    Path& append(const Path& path, const PathHints* hints = nullptr);
 
    Path& append(const PathHints::Hint& hint, const PathHints* hints = nullptr);
 
    Path& append(const GeometryObject& object, const PathHints* hints = nullptr);
 
    Path& append(shared_ptr<const GeometryObject> object, const PathHints* hints = nullptr);
 
    Path& operator+=(const std::vector< shared_ptr<const GeometryObject> >& path) { return append(path); }
 
    Path& operator+=(const GeometryObject::Subtree& paths) { return append(paths); }
 
    Path& operator+=(const Path& path) { return append(path); }
 
    Path& operator+=(const PathHints::Hint& hint) { return append(hint); }
 
    Path& operator+=(const GeometryObject& object) { return append(object); }
 
    Path& operator+=(shared_ptr<const GeometryObject> object) { return append(object); }
 
    PathHints getPathHints() const;
 
    shared_ptr<const GeometryObject> front() const { return objects.front(); }
 
    shared_ptr<const GeometryObject> back() const { return objects.back(); }
 
    operator PathHints() const { return getPathHints(); }
};
 
}
 
#endif // PLASK__GEOMETRY_PATH_H