MLelement.h

Go to the documentation of this file.

#ifndef ML_ELEMENT_H

#define ML_ELEMENT_H

#include "SLelement.h"

namespace bridges {
    namespace datastructure {
        template <typename E>
        class MLelement : public SLelement<E> {

            protected:
                MLelement<E> *sub_list = nullptr; // link to a sublist
                bool tag = false;

            public:

                MLelement(const E& val = E(), const string& lab = string())
                    : SLelement<E> (nullptr, val, lab) {
                    sub_list = nullptr;
                    tag = false;
                }

                MLelement (string label) : SLelement<E> (nullptr, E(), label) {
                    sub_list = nullptr;
                    tag = false;
                }

                MLelement (E e, MLelement<E> *next) : SLelement<E> (next, e, string()) {
                    sub_list = nullptr;
                    tag = false;
                }

                void setSubList(MLelement<E> *sl) {
                    // Hmmm, need to think about removing link data from
                    // an existing sublist
                    this->sub_list = sl;
                    tag = true;

                    // create link data from node to head of sublist
                    if (sl)
                        this->links[sl];

                    // by default, color and shape sublist nodes to distinguish them
                    this->getVisualizer()->setColor(Color("red"));
                    this->getVisualizer()->setShape(SQUARE);
                }

                MLelement *getSubList() {
                    return sub_list;
                }

                MLelement<E> *getNext() override {
                    return (MLelement<E>*) this->next;
                }

                MLelement<E> *getNext() const override {
                    return (MLelement<E>*) this->next;
                }

                void setNext(MLelement<E> *n) {
                    if (n) {
                        if (this->next != n)    // remove old link data, possibly
                            this->links.erase(this->next);

                        this->next = n;
                        this->links[this->next];
                    }
                }

                void setTag(bool t) {
                    tag = t;
                }

                bool getTag() {
                    return tag;
                }
                virtual const string getDStype() const override {
                    return "Multilist";
                }
            private:
                virtual const string getDataStructureRepresentation() const override final {
                    vector<const MLelement<E>*> nodes;

                    // get the list of nodes
                    this->getListElements(this, nodes);

                    // generate the JSON string

                    // map the nodes to a sequence of ids, 0...N-1
                    // then get the JSON string for nodes placeholder
                    // nullptr prevents insertion of other nullptrs
                    unordered_map<const MLelement*, int> node_map { {nullptr, -1} };

                    string nodes_JSON, links_JSON;

                    int i = 0;      // get the JSON string for nodes
                    for (const auto* e : nodes) {
                        if (node_map.emplace(e, i).second)  {
                            // successful emplacement
                            i++;
                            nodes_JSON += e->getElementRepresentation() + COMMA;
                        }
                    }
                    //Remove trailing comma and nullptr entry
                    node_map.erase(nullptr);
                    if (nodes_JSON.size()) {
                        nodes_JSON = nodes_JSON.erase(nodes_JSON.size() - 1);
                    }

                    // generate the links representation
                    for (int k = 0; k < nodes.size(); k++) {
                        if (nodes[k]->next != nullptr) { // link exists
                            links_JSON += this->getLinkRepresentation(nodes[k]->links.at(nodes[k]->next),
                                    to_string(node_map[nodes[k]]),
                                    to_string(node_map[nodes[k]->getNext()])) + COMMA;
                        }
                        if (nodes[k]->tag) {    // sublist link

                            if (nodes[k]->sub_list != nullptr) { // link exists
                                links_JSON += this->getLinkRepresentation(
                                        nodes[k]->links.at(nodes[k]->sub_list),
                                        to_string(node_map[nodes[k]]),
                                        to_string(node_map[nodes[k]->sub_list])) + COMMA;
                            }
                        }
                    }

                    //Remove trailing comma
                    if (links_JSON.size()) {
                        links_JSON = links_JSON.erase(links_JSON.size() - 1);
                    }

                    string ml_list_json =
                        QUOTE + "nodes"  + QUOTE + COLON +
                        OPEN_BOX + nodes_JSON + CLOSE_BOX + COMMA +
                        QUOTE + "links" + QUOTE + COLON + OPEN_BOX +
                        links_JSON + CLOSE_BOX +
                        CLOSE_CURLY;

                    return ml_list_json;
                }
                void getListElements(const MLelement<E> *list,
                    vector<const MLelement<E>*>& nodes) const {

                    auto it = list;
                    while (it != nullptr) {
                        nodes.push_back(it);
                        // if this node has a sublist, recurse
                        if (it->tag) {
                            getListElements(it->sub_list, nodes);
                        }
                        // iterate
                        it = (MLelement<E>*) it->next;
                    }
                }
        };
    }
} // end namespace bridges

#endif