SymbolGroup.h

Go to the documentation of this file.

#include <string>
#include <unordered_map>
#include <memory>
 
using namespace std;
 
#include <JSONutil.h>
#include "DataStructure.h"
#include "Symbol.h"
 
 
#ifndef SYMBOL_GROUP_H
 
#define SYMBOL_GROUP_H
 
namespace bridges {
    namespace datastructure {
        class SymbolGroup : public  Symbol {
            private:
 
                // symbols in this group
          std::vector<std::shared_ptr<Symbol>> symbols;
          
            public:
                SymbolGroup() {
                    symbols.clear();
                }
 
          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);
          }
 
          std::vector<std::shared_ptr<Symbol>> getAllSymbols() const{
            return symbols;
          }
          
                virtual string getShapeType() const override {
                    return "group";
                }
 
                virtual const string getSymbolRepresentation() const override {
 
                    using bridges::JSONUtil::JSONencode;
 
                    
                    // first get the group's representation
                    string symbol_json = getSymbolAttributeRepresentation() + COMMA;
 
                    // process the symbols in the group
                    for (auto& entry : symbols) {
                        symbol_json +=
                            entry->getSymbolRepresentation();
 
                        // remove the close curly brace 
                        if (symbol_json.size())
                            symbol_json.erase(symbol_json.size() - 1);
 
                        // add parent id
                        symbol_json += COMMA + QUOTE + "parentID" + QUOTE + COLON +
                                to_string(getIdentifier()) + CLOSE_CURLY + COMMA;
                    }
                    // remove last comma
                    if (symbols.size()) {
                        symbol_json.erase(symbol_json.size() - 1);
                    }
 
                    return symbol_json;
                }
        };
    }
} // namespace bridges
 
#endif