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 {
                    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 {

                    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