Element.h

Go to the documentation of this file.

#ifndef ELEMENT_H
 
#define ELEMENT_H
 
#include <unordered_set>
#include <unordered_map>
#include <cmath>
 
using namespace std;
 
#include "DataStructure.h"
#include "ElementVisualizer.h"
#include "LinkVisualizer.h"
#include <JSONutil.h>
 
namespace bridges {
    namespace datastructure {
        // forward Declarations
        template <typename K, typename E1, typename E2> class GraphAdjList;
        template <typename K, typename E1, typename E2> class GraphAdjMatrix;
 
        template <typename E> class Element {
                //Used for access to generateJSON() and for links manipulation
                template <typename K, typename E1, typename E2> friend class GraphAdjList;
                template <typename K, typename E1, typename E2> friend class GraphAdjMatrix;
                template <typename K> friend class Array;
                template <typename K> friend class Array1D;
                template <typename K> friend class Array2D;
                template <typename K> friend class Array3D;
 
            private:
                bool debug() const {
                    return false;
                }
                static const unordered_map<const Shape, const string, hash<int >> & ShapeNames() {
 
                    static std::unordered_map<const Shape, const string, hash<int >> sn = {
                        {CIRCLE, "circle"},
                        {SQUARE, "square"},
                        {DIAMOND, "diamond"},
                        {CROSS, "cross"},
                        {TRIANGLE, "triangle"},
                        {WYE, "wye"},
                        {STAR, "star"}
                    };
                    return sn;
                }
 
                //this element's label
                string label;
                // appl. specific data stored with element
                E value = E();
                // this element's visualizer
                ElementVisualizer* elvis;
 
            protected:
 
                // this element's collection of links
                unordered_map<Element*, LinkVisualizer> links;
 
            public:
                explicit Element(const E& val = E(), const string& lab = string()) :
                    label(lab), value(val) {
                    elvis = new ElementVisualizer;
                }
 
                Element(const Element& e)
                    : label(e.label), value(e.value), elvis(new ElementVisualizer(*(e.elvis))), links(e.links) {
                }
 
                Element& operator= (const Element& e) {
                    this->label = e.label;
                    this->value = e.value;
                    *(this->elvis) = *(e.elvis);
                    this->links = e.links;
                    return *this;
                }
 
                E& operator= (E const& e) {
                    this->value = e;
                    return this->value;
                }
 
                virtual ~Element() {
                    delete elvis; // removes the visualizer
                }
 
                ElementVisualizer* getVisualizer() {
                    return elvis;
                }
                const ElementVisualizer* getVisualizer() const {
                    return elvis;
                }
                LinkVisualizer* getLinkVisualizer(const Element* el) {
                    if (links.find(const_cast<Element * >(el)) != links.end()) {
                        return &(links.at(const_cast<Element*>(el)));
                    }
                    if (debug())
                        cerr << "Element " << label << " not linked to Element "
                            << el->getLabel() << ", returning NULL" << endl;
                    return nullptr;
                }
 
                LinkVisualizer* getLinkVisualizer(const Element* el) const {
                    return const_cast<Element*> (this)->getLinkVisualizer(el);
                }
 
                string const & getLabel() const {
                    return label;
                }
 
                void setLabel(const string& lab) {
                    label = lab;
                }
 
                E const & getValue() const {
                    return value;
                }
 
                E & getValue() {
                    return value;
                }
 
                void setValue(const E& val) {
                    value = val;
                }
 
            protected:
                virtual const string getElementRepresentation() const {
                    using bridges::JSONUtil::JSONencode;
                    //write out ElementVisualizer properties
 
                    // first check if location is set and needs to be included
                    string loc_str = "";
                    if ( (elvis->getLocationX() != INFINITY) &&
                        (elvis->getLocationY() != INFINITY) ) {
                        loc_str =  QUOTE + "location" + QUOTE + COLON +
                            OPEN_BOX +
                            JSONencode(elvis->getLocationX())  + COMMA +
                            JSONencode(elvis->getLocationY()) +
                            CLOSE_BOX + COMMA;
                    }
                    return  OPEN_CURLY +
                        QUOTE + "color" + QUOTE + COLON + elvis->getColor().getCSSRepresentation()
                        + COMMA +
                        loc_str +
                        QUOTE + "shape" + QUOTE + COLON + QUOTE +
                        ShapeNames().at(elvis->getShape()) + QUOTE + COMMA +
                        QUOTE + "size" + QUOTE + COLON +
                        JSONencode(elvis->getSize()) + COMMA +
                        QUOTE + "name" + QUOTE + COLON + JSONencode( label) +
                        CLOSE_CURLY;
                }
                /*
                                virtual void getElementRepresentation(rapidjson::Document& d)
                                                                        const {
                                    using namespace rapidjson;
                                    //write out ElementVisualizer properties
 
                                    Value k, v;
                                    d.SetObject();
                                    Document::AllocatorType& allocator = d.GetAllocator();
 
                                    Value el_obj(kObjectType);
 
                                    // first check if location is set and needs to be included
                                    if ( (elvis->getLocationX() != INFINITY) &&
                                        (elvis->getLocationY() != INFINITY) ) {
 
                                        Value loc_arr(kArrayType);
                                        loc_arr.PushBack(v.SetDouble(elvis->getLocationX()),
                                                                allocator);
                                        loc_arr.PushBack(v.SetDouble(elvis->getLocationY()),
                                                                allocator);
                                        el_obj.AddMember("location", loc_arr, allocator);
                                    }
 
                                //  string col_rep = elvis->getColor().getCSSRepresentation();
                                //  v.SetString(col_rep.c_str(), allocator);
                                    Document d2;
                                    elvis->getColor().getCSSRepresentation(d2);
                                    el_obj.AddMember("color", d2["color"], allocator);
                                    string s = ShapeNames().at(elvis->getShape());
                                    v.SetString(s.c_str(), allocator);
                                    el_obj.AddMember("shape", v, allocator);
                                    el_obj.AddMember("size", v.SetDouble(elvis->getSize()), allocator);
                                    v.SetString(label.c_str(), allocator);
                                    el_obj.AddMember("name", v, allocator);
 
                                    // put this into an element
                                    d.AddMember ("element", el_obj, allocator);
                                }
                */
                static const string getLinkRepresentation(
                    const LinkVisualizer& lv,
                    const string& src, const string& dest) {
                    using bridges::JSONUtil::JSONencode;
 
                    //write out LinkVisualizer properties
                    return OPEN_CURLY +
                        QUOTE + "color"     + QUOTE + COLON + lv.getColor().getCSSRepresentation()
                        + COMMA +
                        (!lv.getLabel().empty() ?
                            (QUOTE + "label" + QUOTE + COLON +
                                JSONencode( lv.getLabel()) + COMMA) : "") +
                        QUOTE + "thickness" + QUOTE + COLON +
                        JSONencode(lv.getThickness()) + COMMA +
                        QUOTE + "source"    + QUOTE + COLON + JSONencode(src)  + COMMA +
                        QUOTE + "target"    + QUOTE + COLON + JSONencode(dest) +
                        CLOSE_CURLY;
                }
                static void getLinkRepresentation(
                    const LinkVisualizer& lv,
                    const string& src, const string& dest,
                    rapidjson::Document& d) {
 
                    using namespace rapidjson;
                    Document::AllocatorType& allocator = d.GetAllocator();
                    d.SetObject();
                    Value lv_obj, v, v2;
                    lv_obj.SetObject();
 
                    string col_str = lv.getColor().getCSSRepresentation();
                    v.SetString(col_str.c_str(), allocator);
                    lv_obj.AddMember("color", v, allocator);
                    if (!lv.getLabel().empty()) {
                        v.SetString(lv.getLabel().c_str(), allocator);
                        lv_obj.AddMember("label", v, allocator);
                    }
                    lv_obj.AddMember("thickness", v.SetDouble(lv.getThickness()), allocator);
                    v.SetString(src.c_str(), allocator);
                    lv_obj.AddMember("source", v, allocator);
                    v2.SetString(dest.c_str(), allocator);
                    lv_obj.AddMember("target", v2, allocator);
                    d.AddMember("link", lv_obj, allocator);
                }
            public:
                void setSize(const double& sz) {
                    elvis->setSize(sz);
                }
 
                double getSize() const {
                    return elvis->getSize();
                }
                void setColor(const Color& col) {
                    elvis->setColor(col);
                }
                void setColor(const string col) {
                    elvis->setColor(col);
                }
 
                Color getColor() const {
                    return elvis->getColor();
                }
 
                void setOpacity(double opacity) {
                    elvis->setOpacity(opacity);
                }
 
                double getOpacity() {
                    return elvis->getOpacity();
                }
                void setShape(const Shape& shp) {
                    elvis->setShape(shp);
                }
                Shape getShape() const {
                    return elvis->getShape();
                }
                void setLocation(const double& locX, const double& locY) {
                    elvis->setLocation(locX, locY);
                }
 
                double getLocationX() const {
                    return elvis->getLocationX();
                }
                double getLocationY() const {
                    return elvis->getLocationY();
                }
        };  //end of Element class
 
    }
}//end of bridges namespace
 
#endif