SymbolCollection.h

Go to the documentation of this file.

#include <cmath>
#include <string>
#include <vector>
#include <unordered_map>
 
using namespace std;
 
#include "DataStructure.h"
#include "Symbol.h"
 
#ifndef SYMBOL_COLLECTION_H
 
#define SYMBOL_COLLECTION_H
 
namespace bridges {
    namespace datastructure {
        class SymbolCollection : public  DataStructure {
                // keep track of the shape elements; useful
                // to maintain their properties
            private:
 
                std::vector<std::shared_ptr<Symbol >> symbols;
 
                //  default domain (assuming square coordinate space)
                //  domain emanates in x and y directions, both positive
                //  and negative,
                //  from 0,0
 
            protected:
                mutable float domainxmin = -100.0;
                mutable float domainxmax = 100.0;
                mutable float domainymin = -100.0;
                mutable float domainymax = 100.0;
 
            public:
 
                void setViewport(float xmin, float xmax, float ymin, float
                    ymax) {
                    domainxmin = xmin;
                    domainxmax = xmax;
                    domainymin = ymin;
                    domainymax = ymax;
                }
                SymbolCollection() {
                }
 
                virtual const string getDStype() const override {
                    return "SymbolCollectionV2";
                }
 
                void addSymbolPtr(std::shared_ptr<Symbol> s) {
                    symbols.push_back(s);
                }
 
                template <typename T>
                void addSymbol(T s) {
                    std::shared_ptr<T> pt = std::make_shared<T>(s);
                    addSymbolPtr ((std::shared_ptr<Symbol>)pt);
                }
 
            private:
 
                /*
                 *  @brief Get the JSON representation of the the data structure
                 *  @return JSON string of the symbol representation
                 */
                virtual const string getDataStructureRepresentation() const override {
 
                    string symbol_json = string();
                    for (auto& entry : symbols) {
                        symbol_json +=
                            entry->getSymbolRepresentation() + COMMA;
                    }
                    // remove last comma
                    if (symbols.size()) {
                        symbol_json.erase(symbol_json.size() - 1);
 
                        symbol_json = QUOTE + "domainX" + QUOTE + COLON +
                            OPEN_BOX +
                            to_string(domainxmin) + COMMA + to_string(domainxmax) +
                            CLOSE_BOX + COMMA +
                            QUOTE + "domainY" + QUOTE + COLON +
                            OPEN_BOX +
                            to_string(domainymin) + COMMA + to_string(domainymax) +
                            CLOSE_BOX + COMMA +
                            QUOTE + "symbols" + QUOTE + COLON +
                            OPEN_BOX + symbol_json + CLOSE_BOX + CLOSE_CURLY;
                    }
                    return symbol_json;
                }
        };
    }
} // namespace bridges
 
#endif