StructuredTypes.h

Go to the documentation of this file.

#pragma once

#include <algorithm>
#include <exception>
#include <memory>
#include <vector>
#include <iostream>
#include <sstream>
#include "Utilities.h"

namespace rose {

    class NodeTypeError : std::runtime_error {
    public:
        explicit NodeTypeError(const char *what) : std::runtime_error(what) {}
        explicit NodeTypeError(const std::string &what) : std::runtime_error(what) {}
        NodeTypeError(const NodeTypeError &other) noexcept = default;
    };

    class NodeRangeError : std::out_of_range {
    public:
        explicit NodeRangeError(const char *what) : std::out_of_range(what) {}

        explicit NodeRangeError(const std::string &what) : std::out_of_range(what) {}

        NodeRangeError(const NodeRangeError &other) noexcept = default;
    };

    class ContainerTypeError : public std::runtime_error {
    public:
        ContainerTypeError() = delete;
        explicit ContainerTypeError(const std::string &what) : std::runtime_error(what) {}
        explicit ContainerTypeError(const char *what) : std::runtime_error(what) {}
        ContainerTypeError(const ContainerTypeError& other) = default;
    };

    class Container;

    using IdPathElement = std::pair<std::string,std::string>;

    struct IdPath : public std::vector<IdPathElement> {
        bool absolutePath{};
        static constexpr char PathSep = '/';
        static constexpr char ElementSep = ':';
        static constexpr std::string_view PathWild = "*";
        static constexpr std::string_view PathWildOne = "?";
        static constexpr std::string_view PathParent = "..";

        explicit IdPath(bool absolute = false) : std::vector<IdPathElement>(), absolutePath(absolute) {}

        explicit IdPath(const IdPathElement& element, bool absolute = false) : IdPath(absolute) {
            emplace_back(element);
        }

        [[nodiscard]] std::string str() const {
            bool notFirst = false;
            std::stringstream strm{};
            for (auto &element : *this) {
                if (absolutePath || notFirst) {
                    strm << PathSep;
                }
                strm << element.first;
                if (!element.second.empty())
                    strm << ElementSep << element.second;
                notFirst = true;
            }
            return strm.str();
        }

        std::tuple<bool, int> compare(const IdPath& target) {
            bool wildCard = false;
            int score = 0;
            auto tgt = target.rbegin();
            for (auto& srch : ReverseContainerView(*this)) {
                if (tgt == target.rend())
                    return std::make_tuple(false, 0);
                *tgt;

                if (wildCard) {
                    if (srch.first == PathWild || srch.first == PathWildOne)
                        continue;
                    while ((srch.first != (*tgt).second) && (srch.first != (*tgt).first)) {
                        if (++tgt == target.rend())
                            return std::make_tuple(false, 0);
                    }
                    if (srch.first == (*tgt).second)
                        ++score;
                    wildCard = false;
                } else {
                    if (srch.first == (*tgt).second) {
                        ++score;
                    } else if (srch.first != (*tgt).first) {
                        if (srch.first != PathWildOne) {
                            if (srch.first == PathWild) {
                                wildCard = true;
                            } else {
                                return std::make_tuple(false, 0);
                            }
                        }
                    }
                }
                ++tgt;
            }
            return std::make_tuple(true, score);
        }
    };

    template<typename I>
    inline IdPath parsePathIdString(I inputString) {
        std::stringstream strm;
        if constexpr (std::is_same_v<std::string_view,I>) {
            strm.str(std::string{inputString});
        } else {
            strm.str(inputString);
        }
        IdPath idPath{};
        std::string tmp;
        while (std::getline(strm, tmp, IdPath::PathSep)) {
            if (idPath.empty() && tmp.empty())
                idPath.absolutePath = true;
            else if (!tmp.empty()) {
                std::string e1{}, e2{};
                std::stringstream tstrm{tmp};
                std::getline(tstrm, e1, IdPath::ElementSep);
                std::getline(tstrm, e2, IdPath::ElementSep);
                idPath.emplace_back(e1,e2);
            }
        }
        return idPath;
    }

    struct Id {
        std::string_view idString;

        constexpr explicit operator bool() const noexcept {
            return !idString.empty();
        }
    };

    class Node : public std::enable_shared_from_this<Node> {
    public:
        friend class Container;
        using NodePtr = std::shared_ptr<Node>;

    protected:
        std::weak_ptr<Container> mContainer{};

        Id mId{};

    public:
        Node() = default;

        explicit Node(const std::shared_ptr<Container> &container);

        virtual ~Node() = default;

        static constexpr std::string_view id = "Node";
        virtual std::string_view nodeId() const noexcept {
            return id;
        }

        void setId(const Id& nodeId) noexcept {
            mId = nodeId;
        }

        std::string_view getId() const {
            return mId.idString;
        }

        IdPath getIdPath() const;

        virtual void addedToContainer() {
        }

        std::shared_ptr<Container> container() {
            if (mContainer.expired())
                return nullptr;
            return mContainer.lock();
        }

        std::shared_ptr<Container> container() const {
            if (mContainer.expired())
                return nullptr;
            return mContainer.lock();
        }

        template<typename C>
        std::shared_ptr<C> containerAs() {
            auto c = container();
            if (c) {
                return std::dynamic_pointer_cast<C>(c);
            }
            return nullptr;
        }

        template<typename C>
        std::shared_ptr<C> containerAs() const {
            auto c = container();
            if (c) {
                return std::dynamic_pointer_cast<C>(c);
            }
            return nullptr;
        }

        template<typename NodeType>
        static std::shared_ptr<NodeType> create() {
            return std::make_shared<NodeType>();
        }

        template<typename NodeType, typename ... Args>
        static std::shared_ptr<NodeType> create(Args ... args) {
            return std::make_shared<NodeType>(args ...);
        }

        template<typename NodeType, typename ContainerType, typename ... Args>
        static std::shared_ptr<NodeType> add(ContainerType container, Args ... args) {
            static_assert(std::is_base_of_v<std::shared_ptr<Container>, ContainerType>,
                          "ContainerType must be derived from Container.");
            auto node = std::make_shared<NodeType>(args ...);
            node->mContainer = container;
            container->add(node);
            return node;
        }

        std::shared_ptr<const Node> getNode() const {
            return shared_from_this();
        }

        std::shared_ptr<Node> getNode() {
            return shared_from_this();
        }

        template<typename NodeType>
        std::shared_ptr<const Node> getNode() const {
            return std::dynamic_pointer_cast<NodeType>(shared_from_this());
        }

        template<typename NodeType>
        std::shared_ptr<NodeType> getNode() {
            return std::dynamic_pointer_cast<NodeType>(shared_from_this());
        }

        std::shared_ptr<Node> remove();
    };

    class Container : public Node, public std::vector<Node::NodePtr> {
    public:
        ~Container() override = default;

        static constexpr std::string_view id = "Container";
        std::string_view nodeId() const noexcept override {
            return id;
        }

        virtual void add(const std::shared_ptr<Node> &node) {
            if (auto container = getNode<Container>(); container) {
                container->push_back(node);
                node->mContainer = container;
                node->addedToContainer();
            }
        }

        void remove(const std::shared_ptr<Node>& node) {
            erase(std::remove(begin(), end(), node));
        }
    };

    inline std::shared_ptr<Node> Node::remove() {
        auto node = shared_from_this();
        if (auto container = mContainer.lock(); container) {
            container->remove(node);
        }
        return node;
    }

    inline IdPath Node::getIdPath() const {
        auto node = container();
        auto idPath = node ? node->getIdPath() : IdPath{true};
        idPath.emplace_back(nodeId(),getId());
        return idPath;
    }
}

template<class NodeClass>
inline std::shared_ptr<NodeClass> operator<<(std::shared_ptr<NodeClass> widget, const rose::Id& id) {
    static_assert(std::is_base_of_v<rose::Node, NodeClass>, "WidgetClass must be derived from rose::Node.");
    widget->setId(id);
    return widget;
}

inline std::ostream& operator<<(std::ostream& ostrm, const rose::IdPath& idPath) {
    return ostrm << idPath.str();
}